FIR: fix invoke lookup for SAM resolution

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemBuilder
 import org.jetbrains.kotlin.resolve.calls.inference.addSubtypeConstraintIfCompatible
 import org.jetbrains.kotlin.resolve.calls.inference.model.SimpleConstraintSystemConstraintPosition
+import org.jetbrains.kotlin.types.AbstractTypeChecker
 import org.jetbrains.kotlin.types.model.CaptureStatus
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
 
@@ -409,8 +410,35 @@ fun FirExpression.isFunctional(
             val invokeSymbol =
                 coneType.findContributedInvokeSymbol(
                     session, scopeSession, classLikeExpectedFunctionType, shouldCalculateReturnTypesOfFakeOverrides = false
-                )
+                ) ?: return false
-            return invokeSymbol != null
+            // Make sure the contributed `invoke` is indeed a wanted functional type by checking if types are compatible.
+            val expectedReturnType = classLikeExpectedFunctionType.returnType(session)!!.lowerBoundIfFlexible()
+            val returnTypeCompatible =
+                expectedReturnType is ConeTypeParameterType ||
+                        AbstractTypeChecker.isSubtypeOf(
+                            session.inferenceComponents.ctx,
+                            invokeSymbol.fir.returnTypeRef.coneType,
+                            expectedReturnType,
+                            isFromNullabilityConstraint = false
+                        )
+            if (!returnTypeCompatible) {
+                return false
+            }
+            if (invokeSymbol.fir.valueParameters.size != classLikeExpectedFunctionType.typeArguments.size - 1) {
+                return false
+            }
+            val parameterPairs =
+                invokeSymbol.fir.valueParameters.zip(classLikeExpectedFunctionType.valueParameterTypesIncludingReceiver(session))
+            return parameterPairs.all { (invokeParameter, expectedParameter) ->
+                val expectedParameterType = expectedParameter!!.lowerBoundIfFlexible()
+                expectedParameterType is ConeTypeParameterType ||
+                        AbstractTypeChecker.isSubtypeOf(
+                            session.inferenceComponents.ctx,
+                            invokeParameter.returnTypeRef.coneType,
+                            expectedParameterType,
+                            isFromNullabilityConstraint = false
+                        )
+            }
         }
     }
 }

compiler/testData/diagnostics/tests/j+k/sam/recursiveSamsAndInvoke.kt

@@ -16,7 +16,7 @@ public interface MyListener<F extends MyFuture<?>>  {
 typealias Handler = (cause: Throwable?) -> Unit
 
 fun <T> MyFuture<T>.setup() {
-    <!INAPPLICABLE_CANDIDATE!>addListener<!>(ListenerImpl<T, MyFuture<T>>())
+    addListener(ListenerImpl<T, MyFuture<T>>())
     addListener { }
 }