From 084655d49f886350b4839c9c7d589e447776e868 Mon Sep 17 00:00:00 2001 From: "Anna.Kozlova" Date: Fri, 13 Oct 2017 18:38:12 +0200 Subject: [PATCH] don't capture when checking subtypes deep in hierarchy (IDEA-179850) --- .../intellij/psi/PsiCapturedWildcardType.java | 2 +- .../constraints/StrictSubtypingConstraint.java | 17 ++++++++++++----- .../constraints/SubtypingConstraint.java | 10 +++++----- ...uringDetectingSupertypesDeepInHierarchy.java | 10 ++++++++++ .../lambda/GenericsHighlighting8Test.java | 3 ++- 5 files changed, 30 insertions(+), 12 deletions(-) create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/NoCaptureConversionDuringDetectingSupertypesDeepInHierarchy.java diff --git a/java/java-psi-api/src/com/intellij/psi/PsiCapturedWildcardType.java b/java/java-psi-api/src/com/intellij/psi/PsiCapturedWildcardType.java index e3416e934584..d5a580603a58 100644 --- a/java/java-psi-api/src/com/intellij/psi/PsiCapturedWildcardType.java +++ b/java/java-psi-api/src/com/intellij/psi/PsiCapturedWildcardType.java @@ -55,7 +55,7 @@ public class PsiCapturedWildcardType extends PsiType.Stub { myUpperBound = PsiType.getJavaLangObject(myContext.getManager(), getResolveScope()); } - public static RecursionGuard guard = RecursionManager.createGuard("captureGuard"); + private static final RecursionGuard guard = RecursionManager.createGuard("captureGuard"); public static boolean isCapture() { return guard.currentStack().isEmpty(); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/StrictSubtypingConstraint.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/StrictSubtypingConstraint.java index 6250e2d24f62..3318708d6223 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/StrictSubtypingConstraint.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/StrictSubtypingConstraint.java @@ -29,11 +29,18 @@ import java.util.List; public class StrictSubtypingConstraint implements ConstraintFormula { private PsiType myS; private PsiType myT; + private final boolean myCapture; //t < s public StrictSubtypingConstraint(PsiType t, PsiType s) { + this(t, s, true); + } + + //t < s + public StrictSubtypingConstraint(PsiType t, PsiType s, boolean capture) { myT = t; myS = s; + myCapture = capture; } @Override @@ -87,7 +94,7 @@ public class StrictSubtypingConstraint implements ConstraintFormula { final PsiType tComponentType = ((PsiArrayType)myT).getComponentType(); final PsiType sComponentType = ((PsiArrayType)sType).getComponentType(); if (!(tComponentType instanceof PsiPrimitiveType) && !(sComponentType instanceof PsiPrimitiveType)) { - constraints.add(new StrictSubtypingConstraint(tComponentType, sComponentType)); + constraints.add(new StrictSubtypingConstraint(tComponentType, sComponentType, myCapture)); return true; } return sComponentType instanceof PsiPrimitiveType && sComponentType.equals(tComponentType); @@ -104,7 +111,7 @@ public class StrictSubtypingConstraint implements ConstraintFormula { } final PsiType lowerBound = InferenceSession.getLowerBound(CClass); if (lowerBound != null) { - constraints.add(new StrictSubtypingConstraint(lowerBound, myS)); + constraints.add(new StrictSubtypingConstraint(lowerBound, myS, myCapture)); return true; } return false; @@ -129,7 +136,7 @@ public class StrictSubtypingConstraint implements ConstraintFormula { return myT.isAssignableFrom(myS); } else if (myS instanceof PsiCapturedWildcardType) { - final PsiType upperBound = ((PsiCapturedWildcardType)myS).getUpperBound(); + final PsiType upperBound = ((PsiCapturedWildcardType)myS).getUpperBound(myCapture); if (upperBound instanceof PsiClassType) { sType = (PsiClassType)upperBound; } @@ -178,7 +185,7 @@ public class StrictSubtypingConstraint implements ConstraintFormula { if (myT instanceof PsiIntersectionType) { for (PsiType conjunct : ((PsiIntersectionType)myT).getConjuncts()) { - constraints.add(new StrictSubtypingConstraint(conjunct, myS)); + constraints.add(new StrictSubtypingConstraint(conjunct, myS, myCapture)); } return true; } @@ -186,7 +193,7 @@ public class StrictSubtypingConstraint implements ConstraintFormula { if (myT instanceof PsiCapturedWildcardType) { PsiType lowerBound = ((PsiCapturedWildcardType)myT).getLowerBound(); if (lowerBound != PsiType.NULL) { - constraints.add(new StrictSubtypingConstraint(lowerBound, myS)); + constraints.add(new StrictSubtypingConstraint(lowerBound, myS, myCapture)); } } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/SubtypingConstraint.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/SubtypingConstraint.java index 4c766641440f..af451cd31c89 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/SubtypingConstraint.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/SubtypingConstraint.java @@ -80,12 +80,12 @@ public class SubtypingConstraint implements ConstraintFormula { if (myS instanceof PsiWildcardType) { final PsiType sBound = ((PsiWildcardType)myS).getBound(); if (sBound == null) { - constraints.add(new StrictSubtypingConstraint(tBound, ((PsiWildcardType)myS).getExtendsBound())); + constraints.add(new StrictSubtypingConstraint(tBound, ((PsiWildcardType)myS).getExtendsBound(), false)); return true; } if (((PsiWildcardType)myS).isExtends()) { - constraints.add(new StrictSubtypingConstraint(tBound, sBound)); + constraints.add(new StrictSubtypingConstraint(tBound, sBound, false)); return true; } @@ -97,7 +97,7 @@ public class SubtypingConstraint implements ConstraintFormula { assert false; } else { - constraints.add(new StrictSubtypingConstraint(tBound, myS)); + constraints.add(new StrictSubtypingConstraint(tBound, myS, false)); return true; } } @@ -107,11 +107,11 @@ public class SubtypingConstraint implements ConstraintFormula { if (myS instanceof PsiWildcardType) { final PsiType sBound = ((PsiWildcardType)myS).getBound(); if (sBound != null && ((PsiWildcardType)myS).isSuper()) { - constraints.add(new StrictSubtypingConstraint(sBound, tBound)); + constraints.add(new StrictSubtypingConstraint(sBound, tBound, false)); return true; } } else { - constraints.add(new StrictSubtypingConstraint(myS, tBound)); + constraints.add(new StrictSubtypingConstraint(myS, tBound, false)); return true; } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/NoCaptureConversionDuringDetectingSupertypesDeepInHierarchy.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/NoCaptureConversionDuringDetectingSupertypesDeepInHierarchy.java new file mode 100644 index 000000000000..2ecb99701f3e --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/NoCaptureConversionDuringDetectingSupertypesDeepInHierarchy.java @@ -0,0 +1,10 @@ +import java.util.List; + +class Test { + static void func1 (final List> list, + final List> listOfStrings){ + func2 (list); + func2 (listOfStrings); + } + static void func2( List> list ){ } +} \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/lambda/GenericsHighlighting8Test.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/lambda/GenericsHighlighting8Test.java index 5771ee170278..6c193fb4436d 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/lambda/GenericsHighlighting8Test.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/lambda/GenericsHighlighting8Test.java @@ -19,11 +19,11 @@ import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase; import com.intellij.codeInspection.LocalInspectionTool; import com.intellij.codeInspection.deadCode.UnusedDeclarationInspection; import com.intellij.codeInspection.uncheckedWarnings.UncheckedWarningLocalInspection; +import com.intellij.codeInspection.unusedImport.UnusedImportInspection; import com.intellij.openapi.projectRoots.JavaSdkVersion; import com.intellij.openapi.roots.LanguageLevelProjectExtension; import com.intellij.pom.java.LanguageLevel; import com.intellij.testFramework.IdeaTestUtil; -import com.intellij.codeInspection.unusedImport.UnusedImportInspection; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; @@ -1034,4 +1034,5 @@ public class GenericsHighlighting8Test extends LightDaemonAnalyzerTestCase { public void testBridgeMethodOverriding() { doTest(); } public void testNestedWildcardsWithImplicitBounds() { doTest(); } + public void testNoCaptureConversionDuringDetectingSupertypesDeepInHierarchy() { doTest(); } }