FE: Revert incorrect SAM conversion enhancements brought to K2

dzharkov · Space Team · commit 55ac0b46ba9d · 2025-07-25T15:28:43.000Z
NB: It also makes the test for KT-76453 (hugeMixedCapturedTypes.kt)
 pass the BACKEND phase, which was previously impossible due to
the previous seemingly exponential algorithm

^KT-79535 Fixed
diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/capturedTypes/hugeMixedCapturedType.kt b/compiler/fir/analysis-tests/testData/resolve/inference/capturedTypes/hugeMixedCapturedType.kt
@@ -1,4 +1,4 @@
-// RUN_PIPELINE_TILL: FRONTEND
+// RUN_PIPELINE_TILL: BACKEND
 // ISSUE: KT-76453
 
 // FILE: JavaClass.java
@@ -150,8 +150,6 @@ fun bar(a: JavaClass.A<*, *, *, *, *, *, *, *, *, *>) {
         .foo().foo().foo().foo().foo().foo().foo().foo().foo().foo().foo().foo().foo()
         .foo().foo().foo().foo().foo().foo().foo().foo().foo().foo().foo().foo().foo()
         .foo().foo().foo().foo().foo().foo().foo().foo().foo().foo().foo().foo().foo()
-
-    "".<!UNRESOLVED_REFERENCE!>qwer<!>
 }
 
 /* GENERATED_FIR_TAGS: classDeclaration, functionDeclaration, inProjection, lambdaLiteral, localProperty, nullableType,
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSamResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSamResolver.kt
@@ -10,15 +10,11 @@ import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fakeElement
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSessionComponent
-import org.jetbrains.kotlin.fir.SessionAndScopeSessionHolder
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.caches.FirCache
 import org.jetbrains.kotlin.fir.caches.NullableMap
 import org.jetbrains.kotlin.fir.caches.firCachesFactory
 import org.jetbrains.kotlin.fir.caches.getOrPut
-import org.jetbrains.kotlin.fir.containingClassForStaticMemberAttr
-import org.jetbrains.kotlin.fir.copy
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterBuilder
 import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunction
@@ -27,7 +23,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isAbstract
 import org.jetbrains.kotlin.fir.diagnostics.ConeCannotInferTypeParameterType
 import org.jetbrains.kotlin.fir.diagnostics.ConeIntermediateDiagnostic
 import org.jetbrains.kotlin.fir.extensions.extensionService
-import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticFunctionSymbol
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
@@ -310,80 +305,27 @@ class FirSamResolver(
 private fun FirTypeParameterRefsOwner.buildSubstitutorWithUpperBounds(session: FirSession, type: ConeClassLikeType): ConeSubstitutor {
     if (typeParameters.isEmpty()) return ConeSubstitutor.Empty
 
-    var containsNonSubstitutedArguments = false
-
-    fun createMapping(substitutor: ConeSubstitutor): Map<FirTypeParameterSymbol, ConeKotlinType> {
-        return typeParameters.zip(type.typeArguments).associate { (parameter, projection) ->
-            val typeArgument =
-                projection.type?.let(substitutor::substituteOrSelf)
-                // TODO: Consider using `parameterSymbol.fir.bounds.first().coneType` once sure that it won't fail with exception
-                    ?: parameter.symbol.fir.bounds.firstOrNull()?.coneTypeOrNull
-                        ?.let(substitutor::substituteOrSelf)
-                        ?.also { bound ->
-                            // We only check for type parameters in upper bounds
-                            // because `projection` can contain a type parameter type as well in a situation like
-                            // fun interface Sam<T> {
-                            //      fun invoke()
-                            //      fun foo(s: Sam<T>) {} <--- here T is substituted with T but it's not a recursion
-                            // }
-                            if (bound.containsReferenceToOtherTypeParameter(this)) {
-                                containsNonSubstitutedArguments = true
-                            }
+    val substitutionMap = typeParameters.zip(type.typeArguments).associate { (parameter, projection) ->
+        val typeArgument =
+            projection.type
+            // TODO: Consider using `parameterSymbol.fir.bounds.first().coneType` once sure that it won't fail with exception
+                ?: parameter.symbol.fir.bounds.firstOrNull()?.coneTypeOrNull
+                    ?.let { bound ->
+                        if (!bound.containsReferenceToOtherTypeParameter(this)) {
+                            bound
+                        } else {
+                            val diagnostic = ConeCannotInferTypeParameterType(
+                                parameter.symbol,
+                                reason = "Parameter ${parameter.symbol.name} has a cycle in its upper bounds",
+                            )
+                            ConeErrorType(diagnostic)
                         }
-                    ?: session.builtinTypes.nullableAnyType.coneType
-            Pair(parameter.symbol, typeArgument)
-        }
-    }
-
-    /*
-     *
-     * There might be a case when there is a recursion in upper bounds of SAM type parameters:
-     *
-     * ```
-     * public interface Function<E extends CharSequence, F extends Map<String, E>> {
-     *     E handle(F f);
-     * }
-     * ```
-     *
-     * In this case, it's not enough to just take the upper bound of the parameter, as it may contain the reference to another parameter.
-     * To handle it correctly, we need to substitute upper bounds with existing substitutor too.
-     * This recursive substitution process may last at most as the number of presented type parameters
-     */
-    var substitutor: ConeSubstitutor = ConeSubstitutor.Empty
-
-    for (i in typeParameters.indices) {
-        containsNonSubstitutedArguments = false
-        val mapping = createMapping(substitutor)
-        substitutor = substitutorByMap(mapping, session)
-        if (!containsNonSubstitutedArguments) {
-            break
-        }
-    }
-
-    /*
-    * If there are still unsubstituted
-     *   parameters, then it means that there is a cycle in parameters themselves and it's impossible to infer proper substitution. For that
-     *   case we just create error types for such parameters
-     *
-     * ```
-     * public interface Function1<A extends B, B extends A> {
-     *     B handle(A a);
-     * }
-     * ```
-     */
-    if (containsNonSubstitutedArguments) {
-        val errorSubstitution = typeParameters.associate {
-            val diagnostic = ConeCannotInferTypeParameterType(
-                it.symbol,
-                reason = "Parameter ${it.symbol.name} has a cycle in its upper bounds",
-            )
-            it.symbol to ConeErrorType(diagnostic)
-        }
-        val errorSubstitutor = substitutorByMap(errorSubstitution, session)
-        substitutor = substitutorByMap(createMapping(errorSubstitutor), session)
+                    }
+                ?: session.builtinTypes.nullableAnyType.coneType
+        Pair(parameter.symbol, typeArgument)
     }
 
-    return substitutor
+    return substitutorByMap(substitutionMap, session)
 }
 
 private fun ConeKotlinType.containsReferenceToOtherTypeParameter(owner: FirTypeParameterRefsOwner): Boolean {
diff --git a/compiler/testData/codegen/box/sam/samWithInferenceToDefaultBounds.kt b/compiler/testData/codegen/box/sam/samWithInferenceToDefaultBounds.kt
@@ -1,5 +1,6 @@
 // TARGET_BACKEND: JVM_IR
 // IGNORE_BACKEND_K1: ANY
+// IGNORE_BACKEND_K2: ANY
 // ISSUE: KT-67021
 
 // FILE: Function.java
diff --git a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/javaSamTypeWithRecursionInBounds.fir.diag.txt b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/javaSamTypeWithRecursionInBounds.fir.diag.txt
@@ -1,7 +1,7 @@
-/main.kt:(63,64): error: Cannot infer type for type parameter 'B'. Specify it explicitly.
+/main.kt:(63,64): error: Cannot infer type for type parameter 'A'. Specify it explicitly.
 
-/main.kt:(117,139): error: Cannot infer type for type parameter 'B'. Specify it explicitly.
+/main.kt:(117,139): error: Cannot infer type for type parameter 'A'. Specify it explicitly.
 
-/main.kt:(170,171): error: Cannot infer type for type parameter 'B'. Specify it explicitly.
+/main.kt:(170,171): error: Cannot infer type for type parameter 'A'. Specify it explicitly.
 
-/main.kt:(173,174): error: Cannot infer type for type parameter 'C'. Specify it explicitly.
+/main.kt:(173,174): error: Cannot infer type for type parameter 'B'. Specify it explicitly.
diff --git a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/javaSamTypeWithRecursionInBounds.fir.txt b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/javaSamTypeWithRecursionInBounds.fir.txt
@@ -1,18 +1,18 @@
 FILE: main.kt
     public final fun test_1(): R|kotlin/Unit| {
-        Q|A|.R|/A.foo*s|(<L> = SAM(foo@fun <anonymous>(a: <ERROR TYPE REF: Parameter B has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter A has a cycle in its upper bounds> <inline=NoInline>  {
+        Q|A|.R|/A.foo*s|(<L> = SAM(foo@fun <anonymous>(a: <ERROR TYPE REF: Parameter A has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter B has a cycle in its upper bounds> <inline=NoInline>  {
             Null(null)!!
         }
         ))
     }
     public final fun test_2(): R|kotlin/Unit| {
-        Q|A|.R|/A.foo*s|(<L> = SAM(foo@fun <anonymous>(it: <ERROR TYPE REF: Parameter B has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter A has a cycle in its upper bounds> <inline=NoInline>  {
+        Q|A|.R|/A.foo*s|(<L> = SAM(foo@fun <anonymous>(it: <ERROR TYPE REF: Parameter A has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter B has a cycle in its upper bounds> <inline=NoInline>  {
             Null(null)!!
         }
         ))
     }
     public final fun test_3(): R|kotlin/Unit| {
-        Q|A|.R|/A.bar*s|(<L> = SAM(bar@fun <anonymous>(a: <ERROR TYPE REF: Parameter B has a cycle in its upper bounds>, b: <ERROR TYPE REF: Parameter C has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter A has a cycle in its upper bounds> <inline=NoInline>  {
+        Q|A|.R|/A.bar*s|(<L> = SAM(bar@fun <anonymous>(a: <ERROR TYPE REF: Parameter A has a cycle in its upper bounds>, b: <ERROR TYPE REF: Parameter B has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter C has a cycle in its upper bounds> <inline=NoInline>  {
             Null(null)!!
         }
         ))
diff --git a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.fir.kt b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.fir.kt
@@ -18,14 +18,17 @@ public class A {
 // FILE: main.kt
 fun main() {
     A().foo {
-        x ->
+        <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
         ""
     }
 
     A.bar {
-        x ->
+        <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
         ""
     }
+
+    A.bar(<!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>Function<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> "" })
+    A.bar(Function<CharSequence, Map<String, CharSequence>>{ x -> x[""] })
 }
 
 /* GENERATED_FIR_TAGS: classDeclaration, flexibleType, funWithExtensionReceiver, functionDeclaration, functionalType,
diff --git a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.fir.txt b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.fir.txt
@@ -1,11 +1,19 @@
 FILE: main.kt
     public final fun main(): R|kotlin/Unit| {
-        R|/A.A|().R|/A.foo|(<L> = SAM(foo@fun <anonymous>(x: R|ft<kotlin/collections/MutableMap<kotlin/String!, kotlin/CharSequence!>, kotlin/collections/Map<kotlin/String!, kotlin/CharSequence!>?>|): R|kotlin/CharSequence!| <inline=NoInline>  {
+        R|/A.A|().R|/A.foo|(<L> = SAM(foo@fun <anonymous>(x: <ERROR TYPE REF: Parameter F has a cycle in its upper bounds>): R|kotlin/CharSequence!| <inline=NoInline>  {
             ^ String()
         }
         ))
-        Q|A|.R|/A.bar*s|(<L> = SAM(bar@fun <anonymous>(x: R|ft<kotlin/collections/MutableMap<kotlin/String!, kotlin/CharSequence!>, kotlin/collections/Map<kotlin/String!, kotlin/CharSequence!>?>|): R|kotlin/CharSequence!| <inline=NoInline>  {
+        Q|A|.R|/A.bar*s|(<L> = SAM(bar@fun <anonymous>(x: <ERROR TYPE REF: Parameter F has a cycle in its upper bounds>): R|kotlin/CharSequence!| <inline=NoInline>  {
             ^ String()
         }
         ))
+        Q|A|.R|/A.bar*s<CS errors: /A.bar>#|(R|/Function|<<ERROR TYPE REF: Cannot infer argument for type parameter E>, <ERROR TYPE REF: Cannot infer argument for type parameter F>>(<L> = Function@fun <anonymous>(x: <ERROR TYPE REF: Cannot infer argument for type parameter F>): <ERROR TYPE REF: Cannot infer argument for type parameter E> <inline=NoInline>  {
+            ^ String()
+        }
+        ))
+        Q|A|.R|/A.bar*s|(R|/Function|<R|kotlin/CharSequence|, R|kotlin/collections/Map<kotlin/String, kotlin/CharSequence>|>(<L> = Function@fun <anonymous>(x: R|ft<kotlin/collections/Map<kotlin/String, kotlin/CharSequence>, kotlin/collections/Map<kotlin/String, kotlin/CharSequence>?>|): R|kotlin/CharSequence!| <inline=NoInline>  {
+            ^ R|<local>/x|.R|SubstitutionOverride<kotlin/collections/Map.get: R|kotlin/CharSequence?|>|(String())
+        }
+        ))
     }
diff --git a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.kt b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.kt
@@ -26,6 +26,9 @@ fun main() {
         <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
         ""
     }<!>
+
+    A.bar(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Function<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> "" })
+    A.bar(Function<CharSequence, Map<String, CharSequence>>{ x -> x[""] })
 }
 
 /* GENERATED_FIR_TAGS: classDeclaration, flexibleType, funWithExtensionReceiver, functionDeclaration, functionalType,

Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,18 @@`
`1`	`1`	`FILE: main.kt`
`2`	`2`	`public final fun test_1(): R\|kotlin/Unit\| {`
`3`		`- Q\|A\|.R\|/A.foo*s\|(<L> = SAM(foo@fun <anonymous>(a: <ERROR TYPE REF: Parameter B has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter A has a cycle in its upper bounds> <inline=NoInline> {`
	`3`	`+ Q\|A\|.R\|/A.foo*s\|(<L> = SAM(foo@fun <anonymous>(a: <ERROR TYPE REF: Parameter A has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter B has a cycle in its upper bounds> <inline=NoInline> {`
`4`	`4`	`Null(null)!!`
`5`	`5`	`}`
`6`	`6`	`))`
`7`	`7`	`}`
`8`	`8`	`public final fun test_2(): R\|kotlin/Unit\| {`
`9`		`- Q\|A\|.R\|/A.foo*s\|(<L> = SAM(foo@fun <anonymous>(it: <ERROR TYPE REF: Parameter B has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter A has a cycle in its upper bounds> <inline=NoInline> {`
	`9`	`+ Q\|A\|.R\|/A.foo*s\|(<L> = SAM(foo@fun <anonymous>(it: <ERROR TYPE REF: Parameter A has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter B has a cycle in its upper bounds> <inline=NoInline> {`
`10`	`10`	`Null(null)!!`
`11`	`11`	`}`
`12`	`12`	`))`
`13`	`13`	`}`
`14`	`14`	`public final fun test_3(): R\|kotlin/Unit\| {`
`15`		`- Q\|A\|.R\|/A.bar*s\|(<L> = SAM(bar@fun <anonymous>(a: <ERROR TYPE REF: Parameter B has a cycle in its upper bounds>, b: <ERROR TYPE REF: Parameter C has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter A has a cycle in its upper bounds> <inline=NoInline> {`
	`15`	`+ Q\|A\|.R\|/A.bar*s\|(<L> = SAM(bar@fun <anonymous>(a: <ERROR TYPE REF: Parameter A has a cycle in its upper bounds>, b: <ERROR TYPE REF: Parameter B has a cycle in its upper bounds>): <ERROR TYPE REF: Parameter C has a cycle in its upper bounds> <inline=NoInline> {`
`16`	`16`	`Null(null)!!`
`17`	`17`	`}`
`18`	`18`	`))`
Original file line number	Diff line number	Diff line change
`@@ -18,14 +18,17 @@ public class A {`
`18`	`18`	`// FILE: main.kt`
`19`	`19`	`fun main() {`
`20`	`20`	`A().foo {`
`21`		`- x ->`
	`21`	`+ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->`
`22`	`22`	`""`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`A.bar {`
`26`		`- x ->`
	`26`	`+ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->`
`27`	`27`	`""`
`28`	`28`	`}`
	`29`	`+`
	`30`	`+ A.bar(<!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>Function<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> "" })`
	`31`	`+ A.bar(Function<CharSequence, Map<String, CharSequence>>{ x -> x[""] })`
`29`	`32`	`}`
`30`	`33`
`31`	`34`	`/* GENERATED_FIR_TAGS: classDeclaration, flexibleType, funWithExtensionReceiver, functionDeclaration, functionalType,`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,9 @@ fun main() {`
`26`	`26`	`<!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->`
`27`	`27`	`""`
`28`	`28`	`}<!>`
	`29`	`+`
	`30`	`+ A.bar(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Function<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> "" })`
	`31`	`+ A.bar(Function<CharSequence, Map<String, CharSequence>>{ x -> x[""] })`
`29`	`32`	`}`
`30`	`33`
`31`	`34`	`/* GENERATED_FIR_TAGS: classDeclaration, flexibleType, funWithExtensionReceiver, functionDeclaration, functionalType,`