From 775606f80a99fa066c3a30c1c1011893793fe85b Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Mon, 28 Apr 2014 10:03:53 +0400 Subject: [PATCH] Do not remove trivial substitutions to avoid substituting a new type parameter by default instead of leaving the same #KT-4887 Fixed --- .../diagnostics/tests/substitutions/kt4887.kt | 8 ++++++ .../checkers/JetDiagnosticsTestGenerated.java | 5 ++++ .../impl/AbstractClassDescriptor.java | 5 +--- .../jet/lang/types/TypeSubstitutor.java | 25 +------------------ 4 files changed, 15 insertions(+), 28 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/substitutions/kt4887.kt diff --git a/compiler/testData/diagnostics/tests/substitutions/kt4887.kt b/compiler/testData/diagnostics/tests/substitutions/kt4887.kt new file mode 100644 index 00000000000..4638beaf167 --- /dev/null +++ b/compiler/testData/diagnostics/tests/substitutions/kt4887.kt @@ -0,0 +1,8 @@ +package h + +public class MyClass(param: MyClass) { + fun test() { + val result: MyClass? = null + MyClass(result as MyClass) + } +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index 09f60aa01c8..91bf38a216e 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java @@ -6773,6 +6773,11 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest { doTest("compiler/testData/diagnostics/tests/substitutions/kt1558-short.kt"); } + @TestMetadata("kt4887.kt") + public void testKt4887() throws Exception { + doTest("compiler/testData/diagnostics/tests/substitutions/kt4887.kt"); + } + @TestMetadata("upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt") public void testUpperBoundsSubstitutionForOverloadResolutionWithAmbiguity() throws Exception { doTest("compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt"); diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractClassDescriptor.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractClassDescriptor.java index 91dbb39dee3..1633b3c8762 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractClassDescriptor.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractClassDescriptor.java @@ -116,10 +116,7 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor { List typeParameters = getTypeConstructor().getParameters(); Map substitutionContext = TypeSubstitutor.buildSubstitutionContext(typeParameters, typeArguments); - // Unsafe substitutor is OK, because no recursion can hurt us upon a trivial substitution: - // all the types are written explicitly in the code already, they can not get infinite. - // One exception is *-projections, but they need to be handled separately anyways. - TypeSubstitutor substitutor = TypeSubstitutor.createUnsafe(substitutionContext); + TypeSubstitutor substitutor = TypeSubstitutor.create(substitutionContext); return new SubstitutingScope(getScopeForMemberLookup(), substitutor); } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java b/core/descriptors/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java index 156cf800196..25dd82cc83d 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java @@ -25,7 +25,6 @@ import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.HashMap; -import java.util.Iterator; import java.util.List; import java.util.Map; @@ -72,14 +71,8 @@ public class TypeSubstitutor { return create(new CompositeTypeSubstitution(substitutions)); } - /** No assertion for immediate recursion */ - public static TypeSubstitutor createUnsafe(@NotNull Map substitutionContext) { - Map cleanContext = removeTrivialSubstitutions(substitutionContext); - return create(new MapToTypeSubstitutionAdapter(cleanContext)); - } - public static TypeSubstitutor create(@NotNull Map substitutionContext) { - return createUnsafe(removeTrivialSubstitutions(substitutionContext)); + return create(new MapToTypeSubstitutionAdapter(substitutionContext)); } public static TypeSubstitutor create(@NotNull JetType context) { @@ -226,22 +219,6 @@ public class TypeSubstitutor { return substitutedArguments; } - @NotNull - private static Map removeTrivialSubstitutions(@NotNull Map context) { - Map clean = new HashMap(context); - boolean changed = false; - for (Iterator> iterator = clean.entrySet().iterator(); iterator.hasNext(); ) { - Map.Entry entry = iterator.next(); - TypeConstructor key = entry.getKey(); - TypeProjection value = entry.getValue(); - if (key == value.getType().getConstructor() && value.getProjectionKind() == Variance.INVARIANT) { - iterator.remove(); - changed = true; - } - } - return changed ? clean : context; - } - private static Variance combine(Variance typeParameterVariance, Variance projectionKind) { if (typeParameterVariance == Variance.INVARIANT) return projectionKind; if (projectionKind == Variance.INVARIANT) return typeParameterVariance;