From 8910859fd14ab60e4d553c539b98a6ff5f0b8d2c Mon Sep 17 00:00:00 2001 From: Mikhail Zarechenskiy Date: Fri, 24 May 2019 14:58:59 +0300 Subject: [PATCH] [NI] Implement various optimizations for incorporation algorithm Mostly, these optimisations are picked from the old inference. Also, remove exponential complexity for flexible types in approximation, note that more correct fix for this would be to introduce new types that corresponds just to platform types to avoid nullability problems, but due to complexity it will be done later #KT-31415 Fixed --- .../fir/resolve/calls/ConeInferenceContext.kt | 5 +- .../kotlin/fir/types/ConeTypeContext.kt | 4 +- .../fir/FirDiagnosticsSmokeTestGenerated.java | 10 +++ .../resolve/calls/inference/InferenceUtils.kt | 8 +-- .../components/ConstraintIncorporator.kt | 71 +++++++++++++++---- .../components/ConstraintInjector.kt | 32 ++++++--- .../inference/model/ConstraintStorage.kt | 3 +- .../model/MutableConstraintStorage.kt | 8 ++- .../kotlin/types/TypeApproximator.kt | 14 ++-- compiler/testData/diagnostics/tests/Bounds.kt | 2 +- .../constraintOnFunctionLiteral.kt | 2 +- .../tests/inference/constraints/kt8879.kt | 2 +- .../manyConstraintsDueToFlexibleRawTypes.kt | 32 +++++++++ .../manyConstraintsDueToFlexibleRawTypes.txt | 14 ++++ ...ueToRecursiveFlexibleTypesWithWildcards.kt | 32 +++++++++ ...eToRecursiveFlexibleTypesWithWildcards.txt | 14 ++++ .../inference/possibleCycleOnConstraints.kt | 2 +- ...ypeAliasConstructorCrazyProjections.ni.txt | 2 +- .../checkers/DiagnosticsTestGenerated.java | 10 +++ .../DiagnosticsUsingJavacTestGenerated.java | 10 +++ .../types/checker/ClassicTypeSystemContext.kt | 6 +- .../kotlin/types/model/TypeSystemContext.kt | 4 +- 22 files changed, 239 insertions(+), 48 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt create mode 100644 compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.txt create mode 100644 compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt create mode 100644 compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.txt diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeInferenceContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeInferenceContext.kt index 84291cdf250..6790fd4748f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeInferenceContext.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeInferenceContext.kt @@ -158,9 +158,8 @@ interface ConeInferenceContext : TypeSystemInferenceExtensionContext, } */ - val simpleType = this.asSimpleType() ?: return false - repeat(simpleType.argumentsCount()) { index -> - val argument = simpleType.getArgument(index) + repeat(argumentsCount()) { index -> + val argument = getArgument(index) if (!argument.isStarProjection() && argument.getType().containsInternal(predicate, visited)) return true } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt index 9c0240858c8..5f17710d576 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt @@ -144,13 +144,13 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext { return typeConstructor } - override fun SimpleTypeMarker.argumentsCount(): Int { + override fun KotlinTypeMarker.argumentsCount(): Int { require(this is ConeKotlinType) return this.typeArguments.size } - override fun SimpleTypeMarker.getArgument(index: Int): TypeArgumentMarker { + override fun KotlinTypeMarker.getArgument(index: Int): TypeArgumentMarker { require(this is ConeKotlinType) return this.typeArguments.getOrNull(index) diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java index 8091468eb25..355c0deea66 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java @@ -10059,6 +10059,16 @@ public class FirDiagnosticsSmokeTestGenerated extends AbstractFirDiagnosticsSmok runTest("compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt"); } + @TestMetadata("manyConstraintsDueToFlexibleRawTypes.kt") + public void testManyConstraintsDueToFlexibleRawTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt"); + } + + @TestMetadata("manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt") + public void testManyConstraintsDueToRecursiveFlexibleTypesWithWildcards() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt"); + } + @TestMetadata("notNullConstraintOnNullableType.kt") public void testNotNullConstraintOnNullableType() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt"); diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/InferenceUtils.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/InferenceUtils.kt index 98c4f520fd0..e7528ab7bb1 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/InferenceUtils.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/InferenceUtils.kt @@ -22,10 +22,8 @@ import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.checker.ClassicTypeSystemContext -import org.jetbrains.kotlin.types.model.StubTypeMarker -import org.jetbrains.kotlin.types.model.TypeConstructorMarker -import org.jetbrains.kotlin.types.model.TypeSubstitutorMarker -import org.jetbrains.kotlin.types.model.TypeSystemInferenceExtensionContext +import org.jetbrains.kotlin.types.model.* +import java.util.* fun ConstraintStorage.buildCurrentSubstitutor( context: TypeSystemInferenceExtensionContext, @@ -84,4 +82,4 @@ fun CallableDescriptor.substituteAndApproximateCapturedTypes(substitutor: NewTyp return substitute(TypeSubstitutor.create(wrappedSubstitution)) } -internal fun MutableList.trimToSize(newSize: Int) = subList(newSize, size).clear() \ No newline at end of file +internal fun MutableList.trimToSize(newSize: Int) = subList(newSize, size).clear() diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintIncorporator.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintIncorporator.kt index 6c49a393e4d..ae16402838e 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintIncorporator.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintIncorporator.kt @@ -29,6 +29,8 @@ class ConstraintIncorporator( fun getConstraintsForVariable(typeVariable: TypeVariableMarker): Collection fun addNewIncorporatedConstraint(lowerType: KotlinTypeMarker, upperType: KotlinTypeMarker) + + fun addNewIncorporatedConstraint(typeVariable: TypeVariableMarker, type: KotlinTypeMarker, constraintContext: ConstraintContext) } // \alpha is typeVariable, \beta -- other type variable registered in ConstraintStorage @@ -138,24 +140,49 @@ class ConstraintIncorporator( if (baseConstraint.kind != ConstraintKind.UPPER) { val generatedConstraintType = approximateCapturedTypes(typeForApproximation, toSuper = false) - if (!trivialConstraintTypeInferenceOracle.isGeneratedConstraintTrivial( - otherConstraint, generatedConstraintType, isSubtype = true - ) - ) { - addNewIncorporatedConstraint(generatedConstraintType, targetVariable.defaultType()) - } + addNewConstraint(targetVariable, baseConstraint, otherVariable, otherConstraint, generatedConstraintType, isSubtype = true) } if (baseConstraint.kind != ConstraintKind.LOWER) { val generatedConstraintType = approximateCapturedTypes(typeForApproximation, toSuper = true) - if (!trivialConstraintTypeInferenceOracle.isGeneratedConstraintTrivial( - otherConstraint, generatedConstraintType, isSubtype = false - ) - ) { - addNewIncorporatedConstraint(targetVariable.defaultType(), generatedConstraintType) - } + addNewConstraint(targetVariable, baseConstraint, otherVariable, otherConstraint, generatedConstraintType, isSubtype = false) } } + private fun Context.addNewConstraint( + targetVariable: TypeVariableMarker, + baseConstraint: Constraint, + otherVariable: TypeVariableMarker, + otherConstraint: Constraint, + newConstraint: KotlinTypeMarker, + isSubtype: Boolean + ) { + if (targetVariable in getNestedTypeVariables(newConstraint)) return + if (!containsConstrainingTypeWithoutProjection(newConstraint, otherConstraint)) return + if (trivialConstraintTypeInferenceOracle.isGeneratedConstraintTrivial(otherConstraint, newConstraint, isSubtype)) return + + val derivedFrom = (baseConstraint.derivedFrom + otherConstraint.derivedFrom).toMutableSet() + if (otherVariable in derivedFrom) return + + derivedFrom.add(otherVariable) + + val kind = if (isSubtype) ConstraintKind.LOWER else ConstraintKind.UPPER + + addNewIncorporatedConstraint(targetVariable, newConstraint, ConstraintContext(kind, derivedFrom)) + } + + fun Context.containsConstrainingTypeWithoutProjection( + newConstraint: KotlinTypeMarker, + otherConstraint: Constraint + ): Boolean { + return getNestedArguments(newConstraint).any { + it.getType().typeConstructor() == otherConstraint.type.typeConstructor() && it.getVariance() == TypeVariance.INV + } + } + + fun Context.getNestedTypeVariables(type: KotlinTypeMarker): List = + getNestedArguments(type).mapNotNull { getTypeVariable(it.getType().typeConstructor()) } + + private fun KotlinTypeMarker.substitute(c: Context, typeVariable: TypeVariableMarker, value: KotlinTypeMarker): KotlinTypeMarker { val substitutor = c.typeSubstitutorByTypeConstructor(mapOf(typeVariable.freshTypeConstructor(c) to value)) return substitutor.safeSubstitute(c, this) @@ -166,3 +193,23 @@ class ConstraintIncorporator( if (toSuper) typeApproximator.approximateToSuperType(type, TypeApproximatorConfiguration.IncorporationConfiguration) ?: type else typeApproximator.approximateToSubType(type, TypeApproximatorConfiguration.IncorporationConfiguration) ?: type } + +private fun TypeSystemInferenceExtensionContext.getNestedArguments(type: KotlinTypeMarker): List { + val result = ArrayList() + + val stack = ArrayDeque() + stack.push(createTypeArgument(type, TypeVariance.INV)) + + while (!stack.isEmpty()) { + val typeProjection = stack.pop() + if (typeProjection.isStarProjection()) continue + + result.add(typeProjection) + + val projectedType = typeProjection.getType() + for (argumentIndex in 0 until projectedType.argumentsCount()) { + stack.add(projectedType.getArgument(argumentIndex)) + } + } + return result +} diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintInjector.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintInjector.kt index b0589bf289d..8fdf6b6015a 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintInjector.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintInjector.kt @@ -163,7 +163,24 @@ class ConstraintInjector(val constraintIncorporator: ConstraintIncorporator, val private fun addConstraint(typeVariableConstructor: TypeConstructorMarker, type: KotlinTypeMarker, kind: ConstraintKind) { val typeVariable = c.allTypeVariables[typeVariableConstructor] - ?: error("Should by type variableConstructor: $typeVariableConstructor. ${c.allTypeVariables.values}") + ?: error("Should by type variableConstructor: $typeVariableConstructor. ${c.allTypeVariables.values}") + + addNewIncorporatedConstraint(typeVariable, type, ConstraintContext(kind, emptySet())) + } + + // from ConstraintIncorporator.Context + override fun addNewIncorporatedConstraint(lowerType: KotlinTypeMarker, upperType: KotlinTypeMarker) { + if (c.isAllowedType(lowerType) && c.isAllowedType(upperType)) { + runIsSubtypeOf(lowerType, upperType) + } + } + + override fun addNewIncorporatedConstraint( + typeVariable: TypeVariableMarker, + type: KotlinTypeMarker, + constraintContext: ConstraintContext + ) { + val (kind, derivedFrom) = constraintContext var targetType = type if (targetType.isUninferredParameter()) { @@ -200,14 +217,7 @@ class ConstraintInjector(val constraintIncorporator: ConstraintIncorporator, val } } - possibleNewConstraints.add(typeVariable to Constraint(kind, targetType, position)) - } - - // from ConstraintIncorporator.Context - override fun addNewIncorporatedConstraint(lowerType: KotlinTypeMarker, upperType: KotlinTypeMarker) { - if (c.isAllowedType(lowerType) && c.isAllowedType(upperType)) { - runIsSubtypeOf(lowerType, upperType) - } + possibleNewConstraints.add(typeVariable to Constraint(kind, targetType, position, derivedFrom = derivedFrom)) } override val allTypeVariablesWithConstraints: Collection @@ -234,4 +244,6 @@ class ConstraintInjector(val constraintIncorporator: ConstraintIncorporator, val private fun renderBaseConstraint() = "Base constraint: $baseLowerType <: $baseUpperType from position: $position" } -} \ No newline at end of file +} + +data class ConstraintContext(val kind: ConstraintKind, val derivedFrom: Set) \ No newline at end of file diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/ConstraintStorage.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/ConstraintStorage.kt index 3705a777a05..d810ac5ec3d 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/ConstraintStorage.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/ConstraintStorage.kt @@ -67,7 +67,8 @@ class Constraint( val kind: ConstraintKind, val type: KotlinTypeMarker, // flexible types here is allowed val position: IncorporationConstraintPosition, - val typeHashCode: Int = type.hashCode() + val typeHashCode: Int = type.hashCode(), + val derivedFrom: Set ) { override fun equals(other: Any?): Boolean { if (this === other) return true diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/MutableConstraintStorage.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/MutableConstraintStorage.kt index 9e9f9e8fdc4..a62e32b5b85 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/MutableConstraintStorage.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/model/MutableConstraintStorage.kt @@ -47,7 +47,13 @@ class MutableVariableWithConstraints( } val actualConstraint = if (addAsEqualityConstraint) - Constraint(ConstraintKind.EQUALITY, constraint.type, constraint.position, constraint.typeHashCode) + Constraint( + ConstraintKind.EQUALITY, + constraint.type, + constraint.position, + constraint.typeHashCode, + derivedFrom = constraint.derivedFrom + ) else constraint diff --git a/compiler/resolution/src/org/jetbrains/kotlin/types/TypeApproximator.kt b/compiler/resolution/src/org/jetbrains/kotlin/types/TypeApproximator.kt index 59e8b4f80b2..129d5915fb1 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/types/TypeApproximator.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/types/TypeApproximator.kt @@ -189,9 +189,15 @@ abstract class AbstractTypeApproximator(val ctx: TypeSystemInferenceExtensionCon * Similar for L_1 <: L_2: Let B : resultType <: B. L_2 <: B and L_1 <: B. * I.e. for every type B such as L_2 <: B, L_1 <: B. For example B = L_2. */ + val lowerBound = type.lowerBound() + val upperBound = type.upperBound() - val lowerResult = approximateTo(type.lowerBound(), conf, depth) - val upperResult = approximateTo(type.upperBound(), conf, depth) + val lowerResult = approximateTo(lowerBound, conf, depth) + + val upperResult = if (lowerBound.typeConstructor() == upperBound.typeConstructor()) + lowerResult?.withNullability(upperBound.isMarkedNullable()) + else + approximateTo(upperBound, conf, depth) if (lowerResult == null && upperResult == null) return null /** @@ -202,8 +208,8 @@ abstract class AbstractTypeApproximator(val ctx: TypeSystemInferenceExtensionCon * If U_1 <: U_2.lower .. U_2.upper, then we know only that U_1 <: U_2.upper. */ return createFlexibleType( - lowerResult?.lowerBoundIfFlexible() ?: type.lowerBound(), - upperResult?.upperBoundIfFlexible() ?: type.upperBound() + lowerResult?.lowerBoundIfFlexible() ?: lowerBound, + upperResult?.upperBoundIfFlexible() ?: upperBound ) } else { return type.bound().let { approximateTo(it, conf, depth) ?: it } diff --git a/compiler/testData/diagnostics/tests/Bounds.kt b/compiler/testData/diagnostics/tests/Bounds.kt index f74e9db347a..657750b52dd 100644 --- a/compiler/testData/diagnostics/tests/Bounds.kt +++ b/compiler/testData/diagnostics/tests/Bounds.kt @@ -7,7 +7,7 @@ package boundsWithSubstitutors class C : A() val a = B() - val a1 = B<Int>() + val a1 = B<Int>() class X() diff --git a/compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.kt b/compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.kt index 52ce5f62bd8..664b27f623f 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.kt @@ -3,7 +3,7 @@ package c import java.util.ArrayList -fun Array.toIntArray(): IntArray = this.mapTo(IntArray(size), {it}) +fun Array.toIntArray(): IntArray = this.mapTo(IntArray(size), {it}) fun Array.toArrayList(): ArrayList = this.mapTo(ArrayList(size), {it}) diff --git a/compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt b/compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt index 8320858082a..12ffb646fa1 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt @@ -9,5 +9,5 @@ fun > foo(klass: Inv): String? = null fun bar(): Inv = null!! fun test() { - foo(bar()) + foo(bar()) } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt new file mode 100644 index 00000000000..72fc32469ec --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt @@ -0,0 +1,32 @@ +// !WITH_NEW_INFERENCE +// SKIP_JAVAC + +// FILE: MySettings.java + +import java.util.Collection; + +public class MySettings< + SS extends MySettings, + PS extends MyComparableSettings, + L extends MySettingsListener + > +{ + public Collection getLinkedProjectsSettings() { + return null; + } + + public static MySettings getSettings() { + return null; + } +} + +abstract class MyComparableSettings implements Comparable {} +abstract class MySettingsListener {} + +// FILE: test.kt + +fun test() { + val a = MySettings.getSettings() + a.getLinkedProjectsSettings() + a.linkedProjectsSettings +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.txt b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.txt new file mode 100644 index 00000000000..63b05890938 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.txt @@ -0,0 +1,14 @@ +package + +public fun test(): kotlin.Unit + +public open class MySettings!, /*1*/ PS : MyComparableSettings!, /*2*/ L : MySettingsListener!> { + public constructor MySettings!, /*1*/ PS : MyComparableSettings!, /*2*/ L : MySettingsListener!>() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getLinkedProjectsSettings(): kotlin.collections.(Mutable)Collection! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun getSettings(): MySettings<(raw) MySettings<*, *, *>!, (raw) MyComparableSettings!, (raw) MySettingsListener<*>!>! +} diff --git a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt new file mode 100644 index 00000000000..0e0bb5b1f3e --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt @@ -0,0 +1,32 @@ +// !WITH_NEW_INFERENCE +// SKIP_JAVAC + +// FILE: MySettings.java + +import java.util.Collection + +class MySettings< + SS extends MySettings, + PS extends MyComparableSettings, + L extends MySettingsListener + > +{ + public Collection getLinkedProjectsSettings() { + return null; + } + + public static MySettings getSettings() { + return null; + } +} + +abstract class MyComparableSettings implements Comparable {} +abstract class MySettingsListener {} + +// FILE: test.kt + +fun test() { + val a = MySettings.getSettings() + a.getLinkedProjectsSettings() + a.linkedProjectsSettings +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.txt b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.txt new file mode 100644 index 00000000000..6bfec97b38b --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.txt @@ -0,0 +1,14 @@ +package + +public fun test(): kotlin.Unit + +public/*package*/ open class MySettings!, /*1*/ PS : MyComparableSettings!, /*2*/ L : MySettingsListener!> { + public/*package*/ constructor MySettings!, /*1*/ PS : MyComparableSettings!, /*2*/ L : MySettingsListener!>() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getLinkedProjectsSettings(): kotlin.collections.(Mutable)Collection! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun getSettings(): MySettings<*, *, *>! +} diff --git a/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt b/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt index 0a93b9ec508..b02a17c8f3c 100644 --- a/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt +++ b/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt @@ -7,7 +7,7 @@ fun g (f: () -> List) : T {x = g { Collections.emptyList() } + val x = g { Collections.emptyList() } val y = g { Collections.emptyList() } val z : List = g { Collections.emptyList() } diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.ni.txt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.ni.txt index 4a42df4485d..07f8031809d 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.ni.txt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.ni.txt @@ -1,7 +1,7 @@ package public val test1: [ERROR : Type for BOutIn(listOf(), null!!)] -public val test2: BInIn>> /* = Bound>>, in kotlin.collections.List>> */ +public val test2: BInIn /* = Bound, in kotlin.Nothing> */ public fun listOf(): kotlin.collections.List public final class Bound { diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index 10df9d65378..37e5da660cc 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -10066,6 +10066,16 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest { runTest("compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt"); } + @TestMetadata("manyConstraintsDueToFlexibleRawTypes.kt") + public void testManyConstraintsDueToFlexibleRawTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt"); + } + + @TestMetadata("manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt") + public void testManyConstraintsDueToRecursiveFlexibleTypesWithWildcards() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt"); + } + @TestMetadata("notNullConstraintOnNullableType.kt") public void testNotNullConstraintOnNullableType() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java index 7eebe788465..af232e71107 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java @@ -10061,6 +10061,16 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing runTest("compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt"); } + @TestMetadata("manyConstraintsDueToFlexibleRawTypes.kt") + public void testManyConstraintsDueToFlexibleRawTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt"); + } + + @TestMetadata("manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt") + public void testManyConstraintsDueToRecursiveFlexibleTypesWithWildcards() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt"); + } + @TestMetadata("notNullConstraintOnNullableType.kt") public void testNotNullConstraintOnNullableType() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt"); diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt index a433172aacd..f76162a2870 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt @@ -127,12 +127,12 @@ interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext { return this.constructor } - override fun SimpleTypeMarker.argumentsCount(): Int { - require(this is SimpleType, this::errorMessage) + override fun KotlinTypeMarker.argumentsCount(): Int { + require(this is KotlinType, this::errorMessage) return this.arguments.size } - override fun SimpleTypeMarker.getArgument(index: Int): TypeArgumentMarker { + override fun KotlinTypeMarker.getArgument(index: Int): TypeArgumentMarker { require(this is SimpleType, this::errorMessage) return this.arguments[index] } diff --git a/core/type-system/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt b/core/type-system/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt index bf0126a5124..062d58c8a36 100644 --- a/core/type-system/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt +++ b/core/type-system/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt @@ -167,8 +167,8 @@ interface TypeSystemContext : TypeSystemOptimizationContext { fun SimpleTypeMarker.withNullability(nullable: Boolean): SimpleTypeMarker fun SimpleTypeMarker.typeConstructor(): TypeConstructorMarker - fun SimpleTypeMarker.argumentsCount(): Int - fun SimpleTypeMarker.getArgument(index: Int): TypeArgumentMarker + fun KotlinTypeMarker.argumentsCount(): Int + fun KotlinTypeMarker.getArgument(index: Int): TypeArgumentMarker fun SimpleTypeMarker.getArgumentOrNull(index: Int): TypeArgumentMarker? { if (index in 0 until argumentsCount()) return getArgument(index)