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)