diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/dfaassist/DebuggerInstructionVisitor.java b/java/debugger/impl/src/com/intellij/debugger/engine/dfaassist/DebuggerInstructionVisitor.java index 09ae16681981..ff9d934f4cce 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/dfaassist/DebuggerInstructionVisitor.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/dfaassist/DebuggerInstructionVisitor.java @@ -12,6 +12,7 @@ import com.intellij.openapi.util.TextRange; import com.intellij.psi.*; import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; +import com.intellij.util.ThreeState; import com.siyeh.ig.psiutils.BoolUtils; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -78,9 +79,9 @@ class DebuggerInstructionVisitor extends StandardInstructionVisitor { } @Override - protected boolean checkNotNullable(DfaMemoryState state, - @NotNull DfaValue value, - @Nullable NullabilityProblemKind.NullabilityProblem problem) { + protected ThreeState checkNotNullable(DfaMemoryState state, + @NotNull DfaValue value, + @Nullable NullabilityProblemKind.NullabilityProblem problem) { if (problem != null) { PsiExpression expression = problem.getDereferencedExpression(); if (expression != null && problem.thrownException() != null) { diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/CommonDataflow.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/CommonDataflow.java index a2303d5b8d2c..d2cc8116d7d9 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/CommonDataflow.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/CommonDataflow.java @@ -205,7 +205,7 @@ public final class CommonDataflow { @NotNull private static DataflowResult runDFA(@Nullable PsiElement block) { if (block == null) return new DataflowResult(RunnerResult.NOT_APPLICABLE); - DataFlowRunner runner = new DataFlowRunner(block.getProject(), block, false, ThreeState.UNSURE); + DataFlowRunner runner = new DataFlowRunner(block.getProject(), block, ThreeState.UNSURE); CommonDataflowVisitor visitor = new CommonDataflowVisitor(); RunnerResult result = runner.analyzeMethodRecursively(block, visitor); if (result != RunnerResult.OK) return new DataflowResult(result); diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java index db447cd85d8b..43ab90e9ce24 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java @@ -91,8 +91,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec if (aClass instanceof PsiTypeParameter) return; if (PsiUtil.isLocalOrAnonymousClass(aClass) && !(aClass instanceof PsiEnumConstantInitializer)) return; - final DataFlowRunner runner = new DataFlowRunner(holder.getProject(), aClass, TREAT_UNKNOWN_MEMBERS_AS_NULLABLE, - ThreeState.fromBoolean(IGNORE_ASSERT_STATEMENTS)); + final DataFlowRunner runner = new DataFlowRunner(holder.getProject(), aClass, ThreeState.fromBoolean(IGNORE_ASSERT_STATEMENTS)); DataFlowInstructionVisitor visitor = analyzeDfaWithNestedClosures(aClass, holder, runner, Collections.singletonList(runner.createMemoryState())); List states = visitor.getEndOfInitializerStates(); @@ -117,7 +116,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec public void visitMethod(PsiMethod method) { if (method.isConstructor()) return; final DataFlowRunner runner = new DataFlowRunner( - holder.getProject(), method.getBody(), TREAT_UNKNOWN_MEMBERS_AS_NULLABLE, ThreeState.fromBoolean(IGNORE_ASSERT_STATEMENTS)); + holder.getProject(), method.getBody(), ThreeState.fromBoolean(IGNORE_ASSERT_STATEMENTS)); analyzeMethod(method, runner, Collections.singletonList(runner.createMemoryState())); } @@ -201,7 +200,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec ProblemsHolder holder, DataFlowRunner dfaRunner, Collection initialStates) { - final DataFlowInstructionVisitor visitor = new DataFlowInstructionVisitor(); + final DataFlowInstructionVisitor visitor = new DataFlowInstructionVisitor(TREAT_UNKNOWN_MEMBERS_AS_NULLABLE); final RunnerResult rc = dfaRunner.analyzeMethod(scope, visitor, initialStates); if (rc == RunnerResult.OK) { if (dfaRunner.wasForciblyMerged() && diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInstructionVisitor.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInstructionVisitor.java index cd1f41d5fab1..8a4be253cb3a 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInstructionVisitor.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInstructionVisitor.java @@ -50,6 +50,7 @@ final class DataFlowInstructionVisitor extends StandardInstructionVisitor { private final Map mySwitchLabelsReachability = new HashMap<>(); private boolean myAlwaysReturnsNotNull = true; private final List myEndOfInitializerStates = new ArrayList<>(); + private final boolean myStrictMode; private static final CallMatcher USELESS_SAME_ARGUMENTS = CallMatcher.anyOf( CallMatcher.staticCall(CommonClassNames.JAVA_LANG_MATH, "min", "max").parameterCount(2), @@ -60,6 +61,10 @@ final class DataFlowInstructionVisitor extends StandardInstructionVisitor { CallMatcher.instanceCall(CommonClassNames.JAVA_LANG_STRING, "replace").parameterCount(2) ); + DataFlowInstructionVisitor(boolean strictMode) { + myStrictMode = strictMode; + } + @Override public DfaInstructionState[] visitAssign(AssignInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) { PsiExpression left = instruction.getLExpression(); @@ -144,7 +149,7 @@ final class DataFlowInstructionVisitor extends StandardInstructionVisitor { @Override protected void onTypeCast(PsiTypeCastExpression castExpression, DfaMemoryState state, boolean castPossible) { - myClassCastProblems.computeIfAbsent(castExpression, e -> new StateInfo()).update(state, castPossible); + myClassCastProblems.computeIfAbsent(castExpression, e -> new StateInfo()).update(state, ThreeState.fromBoolean(castPossible)); } StreamEx> problems() { @@ -316,12 +321,15 @@ final class DataFlowInstructionVisitor extends StandardInstructionVisitor { } @Override - protected boolean checkNotNullable(DfaMemoryState state, @NotNull DfaValue value, @Nullable NullabilityProblemKind.NullabilityProblem problem) { + protected ThreeState checkNotNullable(DfaMemoryState state, @NotNull DfaValue value, @Nullable NullabilityProblemKind.NullabilityProblem problem) { if (problem != null && problem.getKind() == NullabilityProblemKind.nullableReturn && !state.isNotNull(value)) { myAlwaysReturnsNotNull = false; } - boolean ok = super.checkNotNullable(state, value, problem); + ThreeState ok = super.checkNotNullable(state, value, problem); + if (!myStrictMode && ok == ThreeState.UNSURE) { + ok = ThreeState.YES; + } if (problem == null) return ok; StateInfo info = myStateInfos.computeIfAbsent(problem, k -> new StateInfo()); info.update(state, ok); @@ -349,14 +357,19 @@ final class DataFlowInstructionVisitor extends StandardInstructionVisitor { boolean ephemeralException; boolean normalException; boolean normalOk; + boolean unknown = true; - void update(DfaMemoryState state, boolean ok) { + void update(DfaMemoryState state, ThreeState ok) { if (state.isEphemeral()) { - if (!ok) ephemeralException = true; + if (ok != ThreeState.YES) ephemeralException = true; + if (ok != ThreeState.UNSURE) unknown = false; } else { - if (ok) normalOk = true; - else normalException = true; + if (ok == ThreeState.YES) normalOk = true; + else { + normalException = true; + if (ok != ThreeState.UNSURE) unknown = false; + } } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java index 367654d72fc6..50af3cdbf1e5 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java @@ -61,21 +61,19 @@ public class DataFlowRunner { } public DataFlowRunner(@NotNull Project project, @Nullable PsiElement context) { - this(project, context, false, ThreeState.NO); + this(project, context, ThreeState.NO); } /** * @param project current project * @param context analysis context element (code block, class, expression, etc.); used to determine whether we can trust * field initializers (e.g. we usually cannot if context is a constructor) - * @param unknownMembersAreNullable if true every parameter or method return value without nullity annotation is assumed to be nullable * @param ignoreAssertions if true, assertion statements will be ignored, as if JVM is started with -da. */ public DataFlowRunner(@NotNull Project project, @Nullable PsiElement context, - boolean unknownMembersAreNullable, @NotNull ThreeState ignoreAssertions) { - myValueFactory = new DfaValueFactory(project, context, unknownMembersAreNullable); + myValueFactory = new DfaValueFactory(project, context); myIgnoreAssertions = ignoreAssertions; } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaUtil.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaUtil.java index 13f1d85d7eff..6578a49e04d7 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DfaUtil.java @@ -293,8 +293,9 @@ public final class DfaUtil { return Integer.MAX_VALUE; // accessed after initialization or at unknown moment } - public static boolean hasInitializationHacks(@NotNull PsiField field) { - PsiClass containingClass = field.getContainingClass(); + public static boolean hasInitializationHacks(@NotNull PsiVariable var) { + if (!(var instanceof PsiField)) return false; + PsiClass containingClass = ((PsiField)var).getContainingClass(); return containingClass != null && System.class.getName().equals(containingClass.getQualifiedName()); } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/NullabilityUtil.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/NullabilityUtil.java index 6d7404e73cca..c244f9d08fb2 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/NullabilityUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/NullabilityUtil.java @@ -39,14 +39,15 @@ public final class NullabilityUtil { if (value.getType() instanceof PsiPrimitiveType) { return DfaNullability.UNKNOWN; } + if (var instanceof PsiField && DfaUtil.hasInitializationHacks((PsiField)var)) { + return DfaNullability.FLUSHED; + } Nullability nullability = DfaPsiUtil.getElementNullabilityIgnoringParameterInference(value.getType(), var); if (nullability != Nullability.UNKNOWN) { return DfaNullability.fromNullability(nullability); } if (var == null) return DfaNullability.UNKNOWN; - Nullability defaultNullability = value.getFactory().suggestNullabilityForNonAnnotatedMember(var); - if (var instanceof PsiParameter && var.getParent() instanceof PsiForeachStatement) { PsiExpression iteratedValue = ((PsiForeachStatement)var.getParent()).getIteratedValue(); if (iteratedValue != null) { @@ -58,13 +59,13 @@ public final class NullabilityUtil { } if (var instanceof PsiField && value.getFactory().canTrustFieldInitializer((PsiField)var)) { - return DfaNullability.fromNullability(getNullabilityFromFieldInitializers((PsiField)var, defaultNullability).second); + return DfaNullability.fromNullability(getNullabilityFromFieldInitializers((PsiField)var).second); } - return DfaNullability.fromNullability(defaultNullability); + return DfaNullability.fromNullability(Nullability.UNKNOWN); } - static Pair getNullabilityFromFieldInitializers(PsiField field, Nullability defaultNullability) { + static Pair getNullabilityFromFieldInitializers(PsiField field) { if (DfaPsiUtil.isFinalField(field)) { PsiExpression initializer = field.getInitializer(); if (initializer != null) { @@ -73,7 +74,7 @@ public final class NullabilityUtil { List initializers = DfaPsiUtil.findAllConstructorInitializers(field); if (initializers.isEmpty()) { - return Pair.create(null, defaultNullability); + return Pair.create(null, Nullability.UNKNOWN); } for (PsiExpression expression : initializers) { @@ -90,7 +91,7 @@ public final class NullabilityUtil { else if (isOnlyImplicitlyInitialized(field)) { return Pair.create(null, Nullability.NOT_NULL); } - return Pair.create(null, defaultNullability); + return Pair.create(null, Nullability.UNKNOWN); } private static boolean isOnlyImplicitlyInitialized(PsiField field) { 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 766526ce08f0..787d41caca90 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 @@ -618,12 +618,12 @@ public class StandardInstructionVisitor extends InstructionVisitor { private DfaValue dereference(DfaMemoryState memState, DfaValue value, @Nullable NullabilityProblemKind.NullabilityProblem problem) { - boolean ok = checkNotNullable(memState, value, problem); + ThreeState ok = checkNotNullable(memState, value, problem); if (value instanceof DfaTypeValue) { DfType dfType = value.getDfType().meet(NOT_NULL_OBJECT); return value.getFactory().fromDfType(dfType == BOTTOM ? NOT_NULL_OBJECT : dfType); } - if (ok) return value; + if (ok != ThreeState.NO) return value; if (memState.isNull(value) && problem != null && problem.getKind() == NullabilityProblemKind.nullableFunctionReturn) { return value.getFactory().fromDfType(NOT_NULL_OBJECT); } @@ -700,9 +700,6 @@ public class StandardInstructionVisitor extends InstructionVisitor { mutable = Mutability.getMutability(realMethod); } type = narrowReturnType(type, qualifierType, realMethod); - if (nullability == Nullability.UNKNOWN) { - nullability = factory.suggestNullabilityForNonAnnotatedMember(targetMethod); - } } DfType dfType = instruction.getContext() instanceof PsiNewExpression ? TypeConstraints.exact(type).asDfType().meet(NOT_NULL_OBJECT) : @@ -768,13 +765,14 @@ public class StandardInstructionVisitor extends InstructionVisitor { return precalculated; } - protected boolean checkNotNullable(DfaMemoryState state, @NotNull DfaValue value, @Nullable NullabilityProblemKind.NullabilityProblem problem) { + protected ThreeState checkNotNullable(DfaMemoryState state, @NotNull DfaValue value, @Nullable NullabilityProblemKind.NullabilityProblem problem) { DfaNullability nullability = DfaNullability.fromDfType(state.getDfType(value)); boolean notNullable = nullability != DfaNullability.NULL && nullability != DfaNullability.NULLABLE; if (notNullable && problem != null && problem.thrownException() != null) { state.applyCondition(value.cond(RelationType.NE, value.getFactory().getNull())); } - return notNullable; + boolean unknown = nullability == DfaNullability.UNKNOWN; + return notNullable ? unknown ? ThreeState.UNSURE : ThreeState.YES : ThreeState.NO; } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/TrackingRunner.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/TrackingRunner.java index 269e29c4f910..f71c959e34e2 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/TrackingRunner.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/TrackingRunner.java @@ -60,9 +60,8 @@ public final class TrackingRunner extends DataFlowRunner { private TrackingRunner(@NotNull PsiElement context, PsiExpression expression, - boolean unknownMembersAreNullable, boolean ignoreAssertions) { - super(context.getProject(), context, unknownMembersAreNullable, ThreeState.fromBoolean(ignoreAssertions)); + super(context.getProject(), context, ThreeState.fromBoolean(ignoreAssertions)); myExpression = expression; } @@ -121,13 +120,12 @@ public final class TrackingRunner extends DataFlowRunner { } @Nullable - public static CauseItem findProblemCause(boolean unknownAreNullables, - boolean ignoreAssertions, + public static CauseItem findProblemCause(boolean ignoreAssertions, PsiExpression expression, DfaProblemType type) { PsiElement body = DfaUtil.getDataflowContext(expression); if (body == null) return null; - TrackingRunner runner = new TrackingRunner(body, expression, unknownAreNullables, ignoreAssertions); + TrackingRunner runner = new TrackingRunner(body, expression, ignoreAssertions); if (!runner.analyze(expression, body)) return null; return runner.findProblemCause(expression, type); } @@ -1230,7 +1228,7 @@ public final class TrackingRunner extends DataFlowRunner { } if (owner instanceof PsiField && getFactory().canTrustFieldInitializer((PsiField)owner)) { Pair fieldNullability = - NullabilityUtil.getNullabilityFromFieldInitializers((PsiField)owner, Nullability.UNKNOWN); + NullabilityUtil.getNullabilityFromFieldInitializers((PsiField)owner); if (fieldNullability.second == DfaNullability.toNullability(nullability)) { PsiExpression initializer = fieldNullability.first; if (initializer != null) { diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaExpressionFactory.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaExpressionFactory.java index 63466516a386..c76a6b586aad 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaExpressionFactory.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/value/DfaExpressionFactory.java @@ -368,7 +368,8 @@ public class DfaExpressionFactory { @Override public boolean isStable() { - return PsiUtil.isJvmLocalVariable(myVariable) || myVariable.hasModifierProperty(PsiModifier.FINAL); + return PsiUtil.isJvmLocalVariable(myVariable) || + (myVariable.hasModifierProperty(PsiModifier.FINAL) && !DfaUtil.hasInitializationHacks(myVariable)); } @NotNull @@ -379,8 +380,7 @@ public class DfaExpressionFactory { return factory.getObjectType(type, DfaPsiUtil.getElementNullability(type, myVariable)); } if (PsiUtil.isJvmLocalVariable(myVariable) || - (myVariable instanceof PsiField && myVariable.hasModifierProperty(PsiModifier.STATIC) && - (!myVariable.hasModifierProperty(PsiModifier.FINAL) || !DfaUtil.hasInitializationHacks((PsiField)myVariable)))) { + (myVariable instanceof PsiField && myVariable.hasModifierProperty(PsiModifier.STATIC))) { return factory.getVarFactory().createVariableValue(this); } return VariableDescriptor.super.createValue(factory, qualifier, forAccessor); 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 bd7146813455..cbe66e33cf22 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 @@ -2,7 +2,6 @@ package com.intellij.codeInspection.dataFlow.value; -import com.intellij.codeInsight.AnnotationUtil; import com.intellij.codeInsight.Nullability; import com.intellij.codeInspection.dataFlow.*; import com.intellij.codeInspection.dataFlow.types.DfType; @@ -10,7 +9,6 @@ import com.intellij.codeInspection.dataFlow.types.DfTypes; import com.intellij.lang.java.JavaLanguage; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Pair; -import com.intellij.patterns.ElementPattern; import com.intellij.psi.*; import com.intellij.psi.impl.source.PsiFieldImpl; import com.intellij.psi.util.*; @@ -25,13 +23,8 @@ import org.jetbrains.annotations.Nullable; import java.util.*; -import static com.intellij.patterns.PsiJavaPatterns.psiMember; -import static com.intellij.patterns.PsiJavaPatterns.psiParameter; -import static com.intellij.patterns.StandardPatterns.or; - public class DfaValueFactory { private final @NotNull List myValues = new ArrayList<>(); - private final boolean myUnknownMembersAreNullable; private final @NotNull FieldChecker myFieldChecker; private final @NotNull Project myProject; private @Nullable DfaVariableValue myAssertionDisabled; @@ -39,12 +32,10 @@ public class DfaValueFactory { /** * @param project a project in which context the analysis is performed * @param context an item to analyze (code-block, expression, class) - * @param unknownMembersAreNullable if true, unknown (non-annotated members) are assumed to be nullable */ - public DfaValueFactory(@NotNull Project project, @Nullable PsiElement context, boolean unknownMembersAreNullable) { + public DfaValueFactory(@NotNull Project project, @Nullable PsiElement context) { myProject = project; myFieldChecker = new FieldChecker(context); - myUnknownMembersAreNullable = unknownMembersAreNullable; myValues.add(null); myVarFactory = new DfaVariableValue.Factory(this); myBoxedFactory = new DfaBoxedValue.Factory(this); @@ -57,21 +48,6 @@ public class DfaValueFactory { return myFieldChecker.canTrustFieldInitializer(field); } - private static final ElementPattern MEMBER_OR_METHOD_PARAMETER = - or(psiMember(), psiParameter().withSuperParent(2, psiMember())); - - - @NotNull - public Nullability suggestNullabilityForNonAnnotatedMember(@NotNull PsiModifierListOwner member) { - if (myUnknownMembersAreNullable && - MEMBER_OR_METHOD_PARAMETER.accepts(member) && - AnnotationUtil.getSuperAnnotationOwners(member).isEmpty()) { - return Nullability.NULLABLE; - } - - return Nullability.UNKNOWN; - } - @NotNull public DfaTypeValue getObjectType(@Nullable PsiType type, @NotNull Nullability nullability) { return fromDfType(DfTypes.typedObject(type, nullability)); diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/fix/FindDfaProblemCauseFix.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/fix/FindDfaProblemCauseFix.java index a24394f960dc..6eeeaa3a6670 100644 --- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/fix/FindDfaProblemCauseFix.java +++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/fix/FindDfaProblemCauseFix.java @@ -73,7 +73,7 @@ public final class FindDfaProblemCauseFix implements OnTheFlyLocalFix, LowPriori ThrowableComputable causeFinder = () -> { PsiExpression element = myAnchor.getElement(); if (element == null) return null; - return TrackingRunner.findProblemCause(myUnknownMembersAsNullable, myIgnoreAssertStatements, element, myProblemType); + return TrackingRunner.findProblemCause(myIgnoreAssertStatements, element, myProblemType); }; TrackingRunner.CauseItem item = ProgressManager.getInstance().runProcessWithProgressSynchronously( () -> ReadAction.compute(causeFinder), JavaBundle.message("progress.title.finding.cause"), true, project); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInspection/DataFlowInspectionTrackerTest.java b/java/java-tests/testSrc/com/intellij/java/codeInspection/DataFlowInspectionTrackerTest.java index 58dfa51c8e3a..d57a584c89b5 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInspection/DataFlowInspectionTrackerTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInspection/DataFlowInspectionTrackerTest.java @@ -52,7 +52,7 @@ public class DataFlowInspectionTrackerTest extends LightJavaCodeInsightFixtureTe assertTrue("Selected element is not an expression: " + selectedText, element instanceof PsiExpression); PsiExpression expression = (PsiExpression)element; TrackingRunner.DfaProblemType problemType = getProblemType(selectedText, expression); - TrackingRunner.CauseItem item = TrackingRunner.findProblemCause(true, false, expression, problemType); + TrackingRunner.CauseItem item = TrackingRunner.findProblemCause(false, expression, problemType); assertNotNull(item); String dump = item.dump(getEditor().getDocument()); PsiComment firstComment = PsiTreeUtil.findChildOfType(file, PsiComment.class); diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ReorderingUtils.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ReorderingUtils.java index 843f9e643871..8cdd30667dca 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ReorderingUtils.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ReorderingUtils.java @@ -337,7 +337,7 @@ public final class ReorderingUtils { List contracts = DfaUtil.addRangeContracts(method, JavaMethodContractUtil.getMethodCallContracts(call)); contracts = ContainerUtil.filter(contracts, c -> c.getReturnValue().isFail() && c.getConditions().size() == 1); if (contracts.isEmpty()) return null; - DfaValueFactory factory = new DfaValueFactory(expression.getProject(), null, false); + DfaValueFactory factory = new DfaValueFactory(expression.getProject(), null); List conditions = new ArrayList<>(); for (MethodContract contract : contracts) { ContractValue condition = contract.getConditions().get(0); diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/controlflow/ConditionCoveredByFurtherConditionInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/controlflow/ConditionCoveredByFurtherConditionInspection.java index ec7b16666cae..2688a098ba5c 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/controlflow/ConditionCoveredByFurtherConditionInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/controlflow/ConditionCoveredByFurtherConditionInspection.java @@ -166,7 +166,7 @@ public class ConditionCoveredByFurtherConditionInspection extends AbstractBaseJa Map values = new HashMap<>(); StandardInstructionVisitor visitor = new StandardInstructionVisitor() { @Override - protected boolean checkNotNullable(DfaMemoryState state, + protected ThreeState checkNotNullable(DfaMemoryState state, @NotNull DfaValue value, @Nullable NullabilityProblemKind.NullabilityProblem problem) { if (value instanceof DfaVariableValue) { @@ -175,7 +175,7 @@ public class ConditionCoveredByFurtherConditionInspection extends AbstractBaseJa state.setDfType(value, ((DfReferenceType)dfType).dropNullability().meet(DfaNullability.NULLABLE.asDfType())); } } - return true; + return ThreeState.YES; } @Override