From 2ee4c955da027dde4457458ffe4d26b0aaa8db13 Mon Sep 17 00:00:00 2001 From: peter Date: Tue, 10 Sep 2013 17:44:12 +0200 Subject: [PATCH] merge DfaNotNullValue into DfaTypeValue --- .../dataFlow/ControlFlowAnalyzer.java | 14 +-- .../dataFlow/DfaMemoryStateImpl.java | 22 ++--- .../dataFlow/StandardInstructionVisitor.java | 28 +++--- .../instructions/BinopInstruction.java | 7 +- .../dataFlow/value/DfaNotNullValue.java | 92 ------------------- .../dataFlow/value/DfaRelationValue.java | 4 +- .../dataFlow/value/DfaTypeValue.java | 23 +++-- .../dataFlow/value/DfaValueFactory.java | 20 ++-- 8 files changed, 52 insertions(+), 158 deletions(-) delete mode 100644 java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaNotNullValue.java diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java index 07e92387ac6e..c87292d0d328 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java @@ -73,8 +73,8 @@ class ControlFlowAnalyzer extends JavaElementVisitor { myIgnoreAssertions = ignoreAssertions; PsiManager manager = codeFragment.getManager(); GlobalSearchScope scope = codeFragment.getResolveScope(); - myRuntimeException = myFactory.getNotNullFactory().create(PsiType.getJavaLangRuntimeException(manager, scope)); - myError = myFactory.getNotNullFactory().create(PsiType.getJavaLangError(manager, scope)); + myRuntimeException = myFactory.createTypeValue(PsiType.getJavaLangRuntimeException(manager, scope), Nullness.NOT_NULL); + myError = myFactory.createTypeValue(PsiType.getJavaLangError(manager, scope), Nullness.NOT_NULL); myNpe = JavaPsiFacade.getElementFactory(manager.getProject()).createTypeByFQClassName(JAVA_LANG_NULL_POINTER_EXCEPTION, scope); myFields = new HashSet(); myCatchStack = new Stack(); @@ -1259,7 +1259,7 @@ class ControlFlowAnalyzer extends JavaElementVisitor { ConditionalGotoInstruction cond = new ConditionalGotoInstruction(null, false, null); addInstruction(cond); addInstruction(new EmptyStackInstruction()); - addInstruction(new PushInstruction(myFactory.getNotNullFactory().create(ref), null)); + addInstruction(new PushInstruction(myFactory.createTypeValue(ref, Nullness.NOT_NULL), null)); addThrowCode(ref); cond.setOffset(myCurrentFlow.getInstructionCount()); } @@ -1390,7 +1390,7 @@ class ControlFlowAnalyzer extends JavaElementVisitor { break; case NOT_NULL_VALUE: PsiType type = expression.getType(); - addInstruction(new PushInstruction(myFactory.createTypeValueWithNullability(type, Nullness.NOT_NULL), null)); + addInstruction(new PushInstruction(myFactory.createTypeValue(type, Nullness.NOT_NULL), null)); addInstruction(new GotoInstruction(exitPoint)); break; case TRUE_VALUE: @@ -1731,7 +1731,7 @@ class ControlFlowAnalyzer extends JavaElementVisitor { } if (dfaValue == null) { PsiType type = expression.getType(); - return myFactory.createTypeValueWithNullability(type, DfaPsiUtil.getElementNullability(type, field)); + return myFactory.createTypeValue(type, DfaPsiUtil.getElementNullability(type, field)); } return dfaValue; } @@ -1794,13 +1794,13 @@ class ControlFlowAnalyzer extends JavaElementVisitor { @Override public void visitSuperExpression(PsiSuperExpression expression) { startElement(expression); - addInstruction(new PushInstruction(myFactory.getNotNullFactory().create(expression.getType()), null)); + addInstruction(new PushInstruction(myFactory.createTypeValue(expression.getType(), Nullness.NOT_NULL), null)); finishElement(expression); } @Override public void visitThisExpression(PsiThisExpression expression) { startElement(expression); - addInstruction(new PushInstruction(myFactory.getNotNullFactory().create(expression.getType()), null)); + addInstruction(new PushInstruction(myFactory.createTypeValue(expression.getType(), Nullness.NOT_NULL), null)); finishElement(expression); } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java index 3d9306ee4e10..3d3a21d2477f 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaMemoryStateImpl.java @@ -277,16 +277,14 @@ public class DfaMemoryStateImpl implements DfaMemoryState { } getVariableState(var).setValue(value); - if (value instanceof DfaNotNullValue) { - DfaTypeValue dfaType = myFactory.getTypeFactory().createTypeValue(((DfaNotNullValue)value).getType()); - DfaRelationValue dfaInstanceof = myFactory.getRelationFactory().createRelation(var, dfaType, JavaTokenType.INSTANCEOF_KEYWORD, false); - applyCondition(dfaInstanceof); - applyCondition(compareToNull(var, true)); - } - else if (value instanceof DfaTypeValue) { + if (value instanceof DfaTypeValue) { getVariableState(var).setNullable(((DfaTypeValue)value).isNullable()); DfaRelationValue dfaInstanceof = myFactory.getRelationFactory().createRelation(var, value, JavaTokenType.INSTANCEOF_KEYWORD, false); - applyInstanceofOrNull(dfaInstanceof); + if (((DfaTypeValue)value).isNotNull()) { + applyCondition(dfaInstanceof); + } else { + applyInstanceofOrNull(dfaInstanceof); + } } else { DfaRelationValue dfaEqual = myFactory.getRelationFactory().createRelation(var, value, JavaTokenType.EQEQ, false); @@ -511,7 +509,7 @@ public class DfaMemoryStateImpl implements DfaMemoryState { @Override public boolean isNull(DfaValue dfaValue) { - if (dfaValue instanceof DfaNotNullValue) return false; + if (dfaValue instanceof DfaTypeValue && ((DfaTypeValue)dfaValue).isNotNull()) return false; if (dfaValue instanceof DfaVariableValue || dfaValue instanceof DfaConstValue) { DfaConstValue dfaNull = myFactory.getConstFactory().getNull(); @@ -613,7 +611,7 @@ public class DfaMemoryStateImpl implements DfaMemoryState { if (dfaLeft instanceof DfaUnknownValue || dfaRight instanceof DfaUnknownValue) return true; boolean isNegated = dfaRelation.isNegated(); - if (dfaLeft instanceof DfaNotNullValue && dfaRight == myFactory.getConstFactory().getNull()) { + if (dfaLeft instanceof DfaTypeValue && ((DfaTypeValue)dfaLeft).isNotNull() && dfaRight == myFactory.getConstFactory().getNull()) { return isNegated; } @@ -629,10 +627,6 @@ public class DfaMemoryStateImpl implements DfaMemoryState { return true; } - if (dfaRight instanceof DfaNotNullValue) { - return true; - } - if (isNull(dfaRight) && compareVariableWithNull(dfaLeft) || isNull(dfaLeft) && compareVariableWithNull(dfaRight)) { return isNegated; } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StandardInstructionVisitor.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StandardInstructionVisitor.java index 90778743c3d3..089b55957e44 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StandardInstructionVisitor.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/StandardInstructionVisitor.java @@ -124,7 +124,7 @@ public class StandardInstructionVisitor extends InstructionVisitor { if (!(psiVariable instanceof PsiField) || !psiVariable.hasModifierProperty(PsiModifier.VOLATILE)) { memState.setVarValue(var, dfaSource); } - } else if (dfaDest instanceof DfaNotNullValue && !memState.checkNotNullable(dfaSource)) { + } else if (dfaDest instanceof DfaTypeValue && ((DfaTypeValue)dfaDest).isNotNull() && !memState.checkNotNullable(dfaSource)) { onAssigningToNotNullableVariable(instruction); } @@ -155,8 +155,8 @@ public class StandardInstructionVisitor extends InstructionVisitor { onInstructionProducesNPE(instruction); if (qualifier instanceof DfaVariableValue) { - final DfaNotNullValue.Factory factory = runner.getFactory().getNotNullFactory(); - memState.setVarValue((DfaVariableValue)qualifier, factory.create(((DfaVariableValue)qualifier).getVariableType())); + memState.setVarValue((DfaVariableValue)qualifier, runner.getFactory() + .createTypeValue(((DfaVariableValue)qualifier).getVariableType(), Nullness.NOT_NULL)); } } @@ -214,7 +214,6 @@ public class StandardInstructionVisitor extends InstructionVisitor { public DfaInstructionState[] visitMethodCall(MethodCallInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) { final PsiExpression[] args = instruction.getArgs(); Map map = myParametersNullability.get(instruction); - final DfaNotNullValue.Factory factory = runner.getFactory().getNotNullFactory(); for (int i = 0; i < args.length; i++) { final DfaValue arg = memState.pop(); PsiExpression expr = args[(args.length - i - 1)]; @@ -222,7 +221,8 @@ public class StandardInstructionVisitor extends InstructionVisitor { if (!memState.checkNotNullable(arg)) { onPassingNullParameter(expr); if (arg instanceof DfaVariableValue) { - memState.setVarValue((DfaVariableValue)arg, factory.create(((DfaVariableValue)arg).getVariableType())); + memState.setVarValue((DfaVariableValue)arg, runner.getFactory() + .createTypeValue(((DfaVariableValue)arg).getVariableType(), Nullness.NOT_NULL)); } } } @@ -236,7 +236,8 @@ public class StandardInstructionVisitor extends InstructionVisitor { if (!memState.checkNotNullable(qualifier)) { onInstructionProducesNPE(instruction); if (qualifier instanceof DfaVariableValue) { - memState.setVarValue((DfaVariableValue)qualifier, factory.create(((DfaVariableValue)qualifier).getVariableType())); + memState.setVarValue((DfaVariableValue)qualifier, runner.getFactory().createTypeValue( + ((DfaVariableValue)qualifier).getVariableType(), Nullness.NOT_NULL)); } } @@ -266,7 +267,7 @@ public class StandardInstructionVisitor extends InstructionVisitor { if (methodType == MethodCallInstruction.MethodType.BOXING) { DfaValue boxed = factory.getBoxedFactory().createBoxed(qualifierValue); - return boxed == null ? factory.getNotNullFactory().create(type) : boxed; + return boxed == null ? factory.createTypeValue(type, Nullness.NOT_NULL) : boxed; } if (methodType == MethodCallInstruction.MethodType.CAST) { @@ -277,7 +278,7 @@ public class StandardInstructionVisitor extends InstructionVisitor { } if (type != null && (type instanceof PsiClassType || type.getArrayDimensions() > 0)) { - return factory.createTypeValueWithNullability(type, myReturnTypeNullability.get(instruction)); + return factory.createTypeValue(type, myReturnTypeNullability.get(instruction)); } return DfaUnknownValue.getInstance(); } @@ -393,17 +394,12 @@ public class StandardInstructionVisitor extends InstructionVisitor { } private void handleInstanceof(InstanceofInstruction instruction, DfaValue dfaRight, DfaValue dfaLeft) { - if ((dfaLeft instanceof DfaTypeValue || dfaLeft instanceof DfaNotNullValue) && dfaRight instanceof DfaTypeValue) { - final PsiType leftType; - if (dfaLeft instanceof DfaNotNullValue) { - leftType = ((DfaNotNullValue)dfaLeft).getType(); - } - else { - leftType = ((DfaTypeValue)dfaLeft).getType(); + if (dfaLeft instanceof DfaTypeValue && dfaRight instanceof DfaTypeValue) { + if (!((DfaTypeValue)dfaLeft).isNotNull()) { myCanBeNullInInstanceof.add(instruction); } - if (((DfaTypeValue)dfaRight).getType().isAssignableFrom(leftType)) { + if (((DfaTypeValue)dfaRight).getType().isAssignableFrom(((DfaTypeValue)dfaLeft).getType())) { return; } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/instructions/BinopInstruction.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/instructions/BinopInstruction.java index 195f538da745..dd2514c41f8e 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/instructions/BinopInstruction.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/instructions/BinopInstruction.java @@ -24,10 +24,7 @@ */ package com.intellij.codeInspection.dataFlow.instructions; -import com.intellij.codeInspection.dataFlow.DataFlowRunner; -import com.intellij.codeInspection.dataFlow.DfaInstructionState; -import com.intellij.codeInspection.dataFlow.DfaMemoryState; -import com.intellij.codeInspection.dataFlow.InstructionVisitor; +import com.intellij.codeInspection.dataFlow.*; import com.intellij.codeInspection.dataFlow.value.DfaValue; import com.intellij.codeInspection.dataFlow.value.DfaValueFactory; import com.intellij.openapi.project.Project; @@ -60,7 +57,7 @@ public class BinopInstruction extends BranchingInstruction { PsiElement anchor = getPsiAnchor(); Project project = myProject; PsiClassType string = PsiType.getJavaLangString(PsiManager.getInstance(project), anchor == null ? GlobalSearchScope.allScope(project) : anchor.getResolveScope()); - return factory.getNotNullFactory().create(string); + return factory.createTypeValue(string, Nullness.NOT_NULL); } public String toString() { diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaNotNullValue.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaNotNullValue.java deleted file mode 100644 index ff2c69f924d4..000000000000 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaNotNullValue.java +++ /dev/null @@ -1,92 +0,0 @@ -/* - * Copyright 2000-2009 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/* - * Created by IntelliJ IDEA. - * User: max - * Date: Jan 28, 2002 - * Time: 6:45:14 PM - * To change template for new class use - * Code Style | Class Templates options (Tools | IDE Options). - */ -package com.intellij.codeInspection.dataFlow.value; - -import com.intellij.psi.PsiType; -import com.intellij.util.containers.HashMap; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -import java.util.ArrayList; - -public class DfaNotNullValue extends DfaValue { - public static class Factory { - private final DfaNotNullValue mySharedInstance; - private final HashMap> myStringToObject; - private final DfaValueFactory myFactory; - - Factory(DfaValueFactory factory) { - myFactory = factory; - mySharedInstance = new DfaNotNullValue(factory); - myStringToObject = new HashMap>(); - } - - @NotNull - public DfaValue create(@Nullable PsiType type) { - if (type == null) return DfaUnknownValue.getInstance(); - mySharedInstance.myType = type; - - String id = mySharedInstance.toString(); - ArrayList conditions = myStringToObject.get(id); - if (conditions == null) { - conditions = new ArrayList(); - myStringToObject.put(id, conditions); - } - else { - for (DfaNotNullValue value : conditions) { - if (value.hardEquals(mySharedInstance)) return value; - } - } - - DfaNotNullValue result = new DfaNotNullValue(type, myFactory); - conditions.add(result); - return result; - } - } - - private PsiType myType; - - private DfaNotNullValue(PsiType myType, DfaValueFactory factory) { - super(factory); - this.myType = myType; - } - - private DfaNotNullValue(DfaValueFactory factory) { - super(factory); - } - - @SuppressWarnings({"HardCodedStringLiteral"}) - public String toString() { - return "@notnull " + myType.getCanonicalText(); - } - - public PsiType getType() { - return myType; - } - - private boolean hardEquals(DfaNotNullValue aNotNull) { - return aNotNull.myType == myType; - } -} diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaRelationValue.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaRelationValue.java index 85158d012cc4..c3593f6eca21 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaRelationValue.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaRelationValue.java @@ -63,10 +63,10 @@ public class DfaRelationValue extends DfaValue { return createCanonicalRelation(relation, negated, dfaLeft, dfaRight); } - if (dfaLeft instanceof DfaNotNullValue && dfaRight instanceof DfaConstValue) { + if (dfaLeft instanceof DfaTypeValue && ((DfaTypeValue)dfaLeft).isNotNull() && dfaRight instanceof DfaConstValue) { return createCanonicalRelation(relation, negated, dfaLeft, dfaRight); } - else if (dfaRight instanceof DfaNotNullValue && dfaLeft instanceof DfaConstValue) { + else if (dfaRight instanceof DfaTypeValue && ((DfaTypeValue)dfaRight).isNotNull() && dfaLeft instanceof DfaConstValue) { return createCanonicalRelation(relation, negated, dfaRight, dfaLeft); } else { diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaTypeValue.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaTypeValue.java index dc699a008c74..f8d781a36585 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaTypeValue.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaTypeValue.java @@ -24,6 +24,7 @@ */ package com.intellij.codeInspection.dataFlow.value; +import com.intellij.codeInspection.dataFlow.Nullness; import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiKeyword; @@ -48,11 +49,11 @@ public class DfaTypeValue extends DfaValue { } @NotNull - public DfaTypeValue createTypeValue(@NotNull PsiType type, boolean nullable) { + public DfaTypeValue createTypeValue(@NotNull PsiType type, Nullness nullable) { type = TypeConversionUtil.erasure(type); mySharedInstance.myType = type; mySharedInstance.myCanonicalText = StringUtil.notNullize(type.getCanonicalText(), PsiKeyword.NULL); - mySharedInstance.myIsNullable = nullable; + mySharedInstance.myNullness = nullable; String id = mySharedInstance.toString(); ArrayList conditions = myStringToObject.get(id); @@ -71,22 +72,22 @@ public class DfaTypeValue extends DfaValue { } public DfaTypeValue createTypeValue(@NotNull PsiType type) { - return createTypeValue(type, false); + return createTypeValue(type, Nullness.UNKNOWN); } } private PsiType myType; private String myCanonicalText; - private boolean myIsNullable; + private Nullness myNullness; private DfaTypeValue(DfaValueFactory factory) { super(factory); } - private DfaTypeValue(PsiType type, boolean isNullable, DfaValueFactory factory, String canonicalText) { + private DfaTypeValue(PsiType type, Nullness nullness, DfaValueFactory factory, String canonicalText) { super(factory); myType = type; - myIsNullable = isNullable; + myNullness = nullness; myCanonicalText = canonicalText; } @@ -95,16 +96,20 @@ public class DfaTypeValue extends DfaValue { } public boolean isNullable() { - return myIsNullable; + return myNullness == Nullness.NULLABLE; + } + + public boolean isNotNull() { + return myNullness == Nullness.NOT_NULL; } @NonNls public String toString() { - return myCanonicalText + ", nullable=" + myIsNullable; + return myCanonicalText + ", nullable=" + myNullness; } private boolean hardEquals(DfaTypeValue aType) { - return Comparing.equal(myCanonicalText, aType.myCanonicalText) && myIsNullable == aType.myIsNullable; + return Comparing.equal(myCanonicalText, aType.myCanonicalText) && myNullness == aType.myNullness; } public boolean isAssignableFrom(DfaTypeValue dfaType) { diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaValueFactory.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaValueFactory.java index 7e7264f344c1..dbe65706f640 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaValueFactory.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaValueFactory.java @@ -46,13 +46,13 @@ public class DfaValueFactory { myVarFactory = new DfaVariableValue.Factory(this); myConstFactory = new DfaConstValue.Factory(this); myBoxedFactory = new DfaBoxedValue.Factory(this); - myNotNullFactory = new DfaNotNullValue.Factory(this); myTypeFactory = new DfaTypeValue.Factory(this); myRelationFactory = new DfaRelationValue.Factory(this); } - public DfaValue createTypeValueWithNullability(@Nullable PsiType type, Nullness nullability) { - return nullability == Nullness.NOT_NULL ? getNotNullFactory().create(type) : getTypeFactory().createTypeValue(type, nullability == Nullness.NULLABLE); + public DfaValue createTypeValue(@Nullable PsiType type, Nullness nullability) { + if (type == null) return DfaUnknownValue.getInstance(); + return getTypeFactory().createTypeValue(type, nullability); } int createID() { @@ -80,14 +80,14 @@ public class DfaValueFactory { } if (psiExpression instanceof PsiNewExpression) { - return getNotNullFactory().create(psiExpression.getType()); + return createTypeValue(psiExpression.getType(), Nullness.NOT_NULL); } final Object value = JavaConstantExpressionEvaluator.computeConstantExpression(psiExpression, false); PsiType type = psiExpression.getType(); if (value != null && type != null) { if (value instanceof String) { - return getNotNullFactory().create(type); // Non-null string literal. + return createTypeValue(type, Nullness.NOT_NULL); // Non-null string literal. } return getConstFactory().createFromValue(value, type, null); } @@ -98,7 +98,7 @@ public class DfaValueFactory { @Nullable public DfaValue createLiteralValue(PsiLiteralExpression literal) { if (literal.getValue() instanceof String) { - return getNotNullFactory().create(literal.getType()); // Non-null string literal. + return createTypeValue(literal.getType(), Nullness.NOT_NULL); // Non-null string literal. } return getConstFactory().create(literal); } @@ -131,7 +131,7 @@ public class DfaValueFactory { PsiExpression initializer = variable.getInitializer(); PsiType type = initializer == null ? null : initializer.getType(); if (initializer != null && type != null && isNotNullExpression(initializer, type)) { - return getNotNullFactory().create(type); + return createTypeValue(type, Nullness.NOT_NULL); } } @@ -173,7 +173,6 @@ public class DfaValueFactory { private final DfaVariableValue.Factory myVarFactory; private final DfaConstValue.Factory myConstFactory; private final DfaBoxedValue.Factory myBoxedFactory; - private final DfaNotNullValue.Factory myNotNullFactory; private final DfaTypeValue.Factory myTypeFactory; private final DfaRelationValue.Factory myRelationFactory; @@ -191,11 +190,6 @@ public class DfaValueFactory { return myBoxedFactory; } - @NotNull - public DfaNotNullValue.Factory getNotNullFactory() { - return myNotNullFactory; - } - @NotNull public DfaTypeValue.Factory getTypeFactory() { return myTypeFactory;