[NI] Remove lambda coersion to Unit in case of error return type(s)

Coersion to Unit from error type leads to misleading type mismatches:
"expected <expected lambda return type> found Unit", despite no user-provided Unit / empty lambda.
These diagnostics were collected, but not reported before, and that had been disguising the issue for a while.

KT-34729 Fixed

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java

@@ -10371,6 +10371,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
                 runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt");
             }
 
+            @TestMetadata("coersionWithAnonymousFunctionsAndUnresolved.kt")
+            public void testCoersionWithAnonymousFunctionsAndUnresolved() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.kt");
+            }
+
             @TestMetadata("indirectCoercionWithExpectedType.kt")
             public void testIndirectCoercionWithExpectedType() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt");

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinResolutionCallbacksImpl.kt

@@ -23,10 +23,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getBinaryWithTypeParent
 import org.jetbrains.kotlin.psi.psiUtil.lastBlockStatementOrThis
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver
-import org.jetbrains.kotlin.resolve.calls.SPECIAL_FUNCTION_NAMES
+import org.jetbrains.kotlin.resolve.calls.components.*
-import org.jetbrains.kotlin.resolve.calls.components.InferenceSession
-import org.jetbrains.kotlin.resolve.calls.components.KotlinResolutionCallbacks
-import org.jetbrains.kotlin.resolve.calls.components.PostponedArgumentsAnalyzer
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
 import org.jetbrains.kotlin.resolve.calls.inference.CoroutineInferenceSession
@@ -95,7 +92,7 @@ class KotlinResolutionCallbacksImpl(
         expectedReturnType: UnwrappedType?,
         annotations: Annotations,
         stubsForPostponedVariables: Map<NewTypeVariable, StubType>
-    ): Pair<List<KotlinCallArgument>, InferenceSession?> {
+    ): ReturnArgumentsAnalysisResult {
         val psiCallArgument = lambdaArgument.psiCallArgument as PSIFunctionKotlinCallArgument
         val outerCallContext = psiCallArgument.outerCallContext
 
@@ -191,7 +188,9 @@ class KotlinResolutionCallbacksImpl(
         trace.record(BindingContext.NEW_INFERENCE_LAMBDA_INFO, psiCallArgument.ktFunction, LambdaInfo.STUB_EMPTY)
 
         var hasReturnWithoutExpression = false
+        var returnArgumentFound = false
         val returnArguments = lambdaInfo.returnStatements.mapNotNullTo(ArrayList()) { (expression, contextInfo) ->
+            returnArgumentFound = true
             val returnedExpression = expression.returnedExpression
             if (returnedExpression != null) {
                 createCallArgument(
@@ -210,6 +209,7 @@ class KotlinResolutionCallbacksImpl(
             if (expectedReturnType?.isUnit() == true || hasReturnWithoutExpression) return@let null // coercion to Unit
 
             // todo lastExpression can be if without else
+            returnArgumentFound = true
             val lastExpressionType = trace.getType(lastExpression)
             val contextInfo = lambdaInfo.lastExpressionInfo
             val lastExpressionTypeInfo = KotlinTypeInfo(lastExpressionType, contextInfo.dataFlowInfoAfter ?: functionTypeInfo.dataFlowInfo)
@@ -218,7 +218,7 @@ class KotlinResolutionCallbacksImpl(
 
         returnArguments.addIfNotNull(lastExpressionArgument)
 
-        return Pair(returnArguments, coroutineSession)
+        return ReturnArgumentsAnalysisResult(ReturnArgumentsInfo(returnArguments, returnArgumentFound), coroutineSession)
     }
 
     private fun getLastDeparentesizedExpression(psiCallArgument: PSIKotlinCallArgument): KtExpression? {

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ResolvedAtomCompleter.kt

@@ -153,7 +153,7 @@ class ResolvedAtomCompleter(
     private val ResolvedLambdaAtom.isCoercedToUnit: Boolean
         get() {
             val returnTypes =
-                resultArguments.map {
+                resultArgumentsInfo.nonErrorArguments.map {
                     val type = it.safeAs<SimpleKotlinCallArgument>()?.receiver?.receiverValue?.type ?: return@map null
                     val unwrappedType = when (type) {
                         is WrappedType -> type.unwrap()
@@ -161,7 +161,7 @@ class ResolvedAtomCompleter(
                     }
                     resultSubstitutor.safeSubstitute(unwrappedType)
                 }
-            if (returnTypes.isEmpty()) return true
+            if (returnTypes.isEmpty() && !resultArgumentsInfo.returnArgumentsExist) return true
             val substitutedTypes = returnTypes.filterNotNull()
             // we have some unsubstituted types
             if (substitutedTypes.isEmpty()) return false
@@ -184,7 +184,7 @@ class ResolvedAtomCompleter(
             )
         updateTraceForLambda(lambda, topLevelTrace, approximatedReturnType)
 
-        for (lambdaResult in lambda.resultArguments) {
+        for (lambdaResult in lambda.resultArgumentsInfo.nonErrorArguments) {
             val resultValueArgument = lambdaResult as? PSIKotlinCallArgument ?: continue
             val newContext =
                 topLevelCallContext.replaceDataFlowInfo(resultValueArgument.dataFlowInfoAfterThisArgument)

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ExternalComponents.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintInjector
 import org.jetbrains.kotlin.resolve.calls.inference.model.NewTypeVariable
 import org.jetbrains.kotlin.resolve.calls.model.*
@@ -42,6 +41,16 @@ interface KotlinResolutionStatelessCallbacks {
     ): SimpleConstraintSystem
 }
 
+data class ReturnArgumentsInfo(
+    val nonErrorArguments: List<KotlinCallArgument>,
+    val returnArgumentsExist: Boolean
+)
+
+data class ReturnArgumentsAnalysisResult(
+    val returnArgumentsInfo: ReturnArgumentsInfo,
+    val inferenceSession: InferenceSession?
+)
+
 // This components hold state (trace). Work with this carefully.
 interface KotlinResolutionCallbacks {
     fun analyzeAndGetLambdaReturnArguments(
@@ -52,7 +61,7 @@ interface KotlinResolutionCallbacks {
         expectedReturnType: UnwrappedType?, // null means, that return type is not proper i.e. it depends on some type variables
         annotations: Annotations,
         stubsForPostponedVariables: Map<NewTypeVariable, StubType>
-    ): Pair<List<KotlinCallArgument>, InferenceSession?>
+    ): ReturnArgumentsAnalysisResult
 
     fun bindStubResolvedCallForCandidate(candidate: ResolvedCallAtom)
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/PostponedArgumentsAnalyzer.kt

@@ -118,7 +118,7 @@ class PostponedArgumentsAnalyzer(
             else FilteredAnnotations(annotations, true) { it != KotlinBuiltIns.FQ_NAMES.extensionFunctionType }
         }
 
-        val (returnArguments, inferenceSession) = resolutionCallbacks.analyzeAndGetLambdaReturnArguments(
+        val (returnArgumentsInfo, inferenceSession) = resolutionCallbacks.analyzeAndGetLambdaReturnArguments(
             lambda.atom,
             lambda.isSuspend,
             receiver,
@@ -128,21 +128,21 @@ class PostponedArgumentsAnalyzer(
             stubsForPostponedVariables.cast()
         )
 
-        returnArguments.forEach { c.addSubsystemFromArgument(it) }
+        returnArgumentsInfo.nonErrorArguments.forEach { c.addSubsystemFromArgument(it) }
 
-        val subResolvedKtPrimitives = returnArguments.map {
+        val subResolvedKtPrimitives = returnArgumentsInfo.nonErrorArguments.map {
             resolveKtPrimitive(
                 c.getBuilder(), it, lambda.returnType.let(::substitute), diagnosticHolder, isReceiver = false
             )
         }
 
-        if (returnArguments.isEmpty()) {
+        if (!returnArgumentsInfo.returnArgumentsExist) {
             val unitType = lambda.returnType.builtIns.unitType
             val lambdaReturnType = lambda.returnType.let(::substitute)
             c.getBuilder().addSubtypeConstraint(unitType, lambdaReturnType, LambdaArgumentConstraintPosition(lambda))
         }
 
-        lambda.setAnalyzedResults(returnArguments, subResolvedKtPrimitives)
+        lambda.setAnalyzedResults(returnArgumentsInfo, subResolvedKtPrimitives)
 
         if (inferenceSession != null) {
             val storageSnapshot = c.getBuilder().currentStorage()

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolutionAtoms.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.resolve.calls.model
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.resolve.calls.components.CallableReferenceCandidate
+import org.jetbrains.kotlin.resolve.calls.components.ReturnArgumentsInfo
 import org.jetbrains.kotlin.resolve.calls.components.TypeArgumentsToParametersMapper
 import org.jetbrains.kotlin.resolve.calls.components.extractInputOutputTypesFromCallableReferenceExpectedType
 import org.jetbrains.kotlin.resolve.calls.inference.components.FreshVariableNewTypeSubstitutor
@@ -115,14 +116,14 @@ class ResolvedLambdaAtom(
     val typeVariableForLambdaReturnType: TypeVariableForLambdaReturnType?,
     override val expectedType: UnwrappedType?
 ) : PostponedResolvedAtom() {
-    lateinit var resultArguments: List<KotlinCallArgument>
+    lateinit var resultArgumentsInfo: ReturnArgumentsInfo
         private set
 
     fun setAnalyzedResults(
-        resultArguments: List<KotlinCallArgument>,
+        resultArguments: ReturnArgumentsInfo,
         subResolvedAtoms: List<ResolvedAtom>
     ) {
-        this.resultArguments = resultArguments
+        this.resultArgumentsInfo = resultArguments
         setAnalyzedResults(subResolvedAtoms)
     }
 

compiler/testData/diagnostics/tests/AutoCreatedIt.kt

@@ -10,7 +10,7 @@ fun text() {
     bar1 {1}
     bar1 {it + 1}
 
-    bar2 {<!TYPE_MISMATCH!><!>}
+    bar2 <!NI;TYPE_MISMATCH!>{<!TYPE_MISMATCH!><!>}<!>
     bar2 {1}
     bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
     bar2 <!NI;TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!>}<!>

compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.fir.kt

@@ -1,4 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
 
 interface JPAEntityClass<D> {
     fun <T> T.findByName(s: String): D {null!!}

compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.kt

@@ -1,4 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
 
 interface JPAEntityClass<D> {
     fun <T> T.findByName(s: String): D {null!!}
@@ -9,7 +10,7 @@ class Foo {
 }
 
 fun main() {
-    with("", {
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>with<!>("", {
         Foo.<!UNRESOLVED_REFERENCE!>findByName<!>("")
     })
     with(Foo) {

compiler/testData/diagnostics/tests/generics/projectionsScope/extensionReceiverTypeMismatch.kt

@@ -6,12 +6,12 @@ class A<T> {
 class Out<out E>
 
 fun test(x: A<out CharSequence>, y: Out<CharSequence>) {
-    with(x) {
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>with<!>(x) {
         // TODO: this diagnostic could be replaced with TYPE_MISMATCH_DUE_TO_TYPE_PROJECTION
         "".<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!>()
         <!OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>y<!>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>bar<!>()
 
-        with(y) {
+        <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>with<!>(y) {
             <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>bar<!>()
         }
     }

compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.fir.kt

@@ -0,0 +1,74 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+fun takeFnToAny(fn: () -> Any) {}
+fun takeFnToUnit(fn: () -> Unit) {}
+fun <P> takeFnToParameter(fn: () -> P) {}
+
+fun testAny() {
+    takeFnToAny {  }
+    takeFnToAny { Unit }
+    takeFnToAny { <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToAny { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToAny { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToAny(fun() = Unit)
+    takeFnToAny(fun() {})
+    takeFnToAny(fun() { return })
+    takeFnToAny(fun() { return Unit })
+    takeFnToAny(fun(): Unit {})
+    takeFnToAny(fun(): Unit { return })
+    takeFnToAny(fun(): Unit { return Unit })
+    takeFnToAny(fun() { if (true) return })
+    takeFnToAny(fun() { if (true) return Unit })
+    takeFnToAny(fun() = <!UNRESOLVED_REFERENCE!>unresolved<!>())
+    takeFnToAny(fun() { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToAny(fun(): Unit { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToAny(fun() { return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToAny(fun() { if (true ) return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+}
+
+fun testUnit() {
+    takeFnToUnit {  }
+    takeFnToUnit { Unit }
+    takeFnToUnit { <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToUnit { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToUnit { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToUnit(fun() = Unit)
+    takeFnToUnit(fun() {})
+    takeFnToUnit(fun() { return })
+    takeFnToUnit(fun() { return Unit })
+    takeFnToUnit(fun(): Unit {})
+    takeFnToUnit(fun(): Unit { return })
+    takeFnToUnit(fun(): Unit { return Unit })
+    takeFnToUnit(fun() { if (true) return })
+    takeFnToUnit(fun() { if (true) return Unit })
+    takeFnToUnit(fun() = <!UNRESOLVED_REFERENCE!>unresolved<!>())
+    takeFnToUnit(fun() { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToUnit(fun(): Unit { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToUnit(fun() { return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToUnit(fun() { if (true ) return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+}
+
+fun testParameter() {
+    takeFnToParameter {  }
+    takeFnToParameter { Unit }
+    takeFnToParameter { <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToParameter { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToParameter {
+        if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>()
+    }
+    takeFnToParameter(fun() = Unit)
+    takeFnToParameter(fun() {})
+    takeFnToParameter(fun() { return })
+    takeFnToParameter(fun() { return Unit })
+    takeFnToParameter(fun(): Unit {})
+    takeFnToParameter(fun(): Unit { return })
+    takeFnToParameter(fun(): Unit { return Unit })
+    takeFnToParameter(fun() { if (true) return })
+    takeFnToParameter(fun() { if (true) return Unit })
+    takeFnToParameter(fun() = <!UNRESOLVED_REFERENCE!>unresolved<!>())
+    takeFnToParameter(fun() { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToParameter(fun(): Unit { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToParameter(fun() { return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToParameter(fun() { if (true ) return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+}

compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.kt

@@ -0,0 +1,74 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+fun takeFnToAny(fn: () -> Any) {}
+fun takeFnToUnit(fn: () -> Unit) {}
+fun <P> takeFnToParameter(fn: () -> P) {}
+
+fun testAny() {
+    takeFnToAny {  }
+    takeFnToAny { Unit }
+    takeFnToAny { <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToAny { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToAny { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToAny(fun() = Unit)
+    takeFnToAny(fun() {})
+    takeFnToAny(fun() { return })
+    takeFnToAny(fun() { return Unit })
+    takeFnToAny(fun(): Unit {})
+    takeFnToAny(fun(): Unit { return })
+    takeFnToAny(fun(): Unit { return Unit })
+    takeFnToAny(fun() { if (true) return })
+    takeFnToAny(fun() { if (true) return Unit })
+    takeFnToAny(fun() = <!UNRESOLVED_REFERENCE!>unresolved<!>())
+    takeFnToAny(fun() { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToAny(fun(): Unit { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToAny(fun() { return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToAny(fun() { if (true ) return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+}
+
+fun testUnit() {
+    takeFnToUnit {  }
+    takeFnToUnit { Unit }
+    takeFnToUnit { <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToUnit { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToUnit { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToUnit(fun() = Unit)
+    takeFnToUnit(fun() {})
+    takeFnToUnit(fun() { return })
+    takeFnToUnit(fun() { return Unit })
+    takeFnToUnit(fun(): Unit {})
+    takeFnToUnit(fun(): Unit { return })
+    takeFnToUnit(fun(): Unit { return Unit })
+    takeFnToUnit(fun() { if (true) return })
+    takeFnToUnit(fun() { if (true) return Unit })
+    takeFnToUnit(fun() = <!UNRESOLVED_REFERENCE!>unresolved<!>())
+    takeFnToUnit(fun() { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToUnit(fun(): Unit { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToUnit(fun() { return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToUnit(fun() { if (true ) return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+}
+
+fun testParameter() {
+    takeFnToParameter {  }
+    takeFnToParameter { Unit }
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeFnToParameter<!> { <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToParameter { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeFnToParameter<!> {
+        if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>()
+    }
+    takeFnToParameter(fun() = Unit)
+    takeFnToParameter(fun() {})
+    takeFnToParameter(fun() { return })
+    takeFnToParameter(fun() { return Unit })
+    takeFnToParameter(fun(): Unit {})
+    takeFnToParameter(fun(): Unit { return })
+    takeFnToParameter(fun(): Unit { return Unit })
+    takeFnToParameter(fun() { if (true) return })
+    takeFnToParameter(fun() { if (true) return Unit })
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeFnToParameter<!>(fun() = <!UNRESOLVED_REFERENCE!>unresolved<!>())
+    takeFnToParameter(fun() { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToParameter(fun(): Unit { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToParameter(fun() { return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+    takeFnToParameter(fun() { if (true ) return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
+}

compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.txt

@@ -0,0 +1,8 @@
+package
+
+public fun takeFnToAny(/*0*/ fn: () -> kotlin.Any): kotlin.Unit
+public fun </*0*/ P> takeFnToParameter(/*0*/ fn: () -> P): kotlin.Unit
+public fun takeFnToUnit(/*0*/ fn: () -> kotlin.Unit): kotlin.Unit
+public fun testAny(): kotlin.Unit
+public fun testParameter(): kotlin.Unit
+public fun testUnit(): kotlin.Unit

compiler/testData/diagnostics/tests/inference/kt28654.kt

@@ -2,7 +2,7 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 // Related issue: KT-28654
 
-fun <K> select(): K = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>run { <!OI;TYPE_MISMATCH!><!>}<!>
+fun <K> select(): K = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>run <!NI;TYPE_MISMATCH!>{ <!OI;TYPE_MISMATCH!><!>}<!><!>
 
 fun test() {
     val x: Int = select()

compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.kt

@@ -13,7 +13,7 @@ fun insideJob1() = doTheJob1()
 suspend fun insideJob2() = doTheJob2()
 suspend fun insideJob3() = doTheJob3()
 
-fun doTheJob0() = simpleAsync0 { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>insideJob0<!>()<!> }
+fun doTheJob0() = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>simpleAsync0<!> { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>insideJob0<!>()<!> }
-fun doTheJob1() = simpleAsync1 { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>insideJob1<!>()<!> }
+fun doTheJob1() = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>simpleAsync1<!> { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>insideJob1<!>()<!> }
-suspend fun doTheJob2() = simpleAsync2 { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>insideJob2<!>()<!> }
+suspend fun doTheJob2() = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>simpleAsync2<!> { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>insideJob2<!>()<!> }
-suspend fun doTheJob3() = simpleAsync3 { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>insideJob3<!>()<!> }
+suspend fun doTheJob3() = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>simpleAsync3<!> { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>insideJob3<!>()<!> }

compiler/testData/diagnostics/tests/inference/regressions/kt2741.fir.kt

@@ -1,4 +1,6 @@
 //KT-2741 Compiler can't infer a type of a function literal parameter when its body contains errors
+// !WITH_NEW_INFERENCE
+
 package a
 
 fun <T, R: Comparable<R>> Iterable<T>._sortBy(f: (T) -> R): List<T> = throw Exception()

compiler/testData/diagnostics/tests/inference/regressions/kt2741.kt

@@ -1,4 +1,6 @@
 //KT-2741 Compiler can't infer a type of a function literal parameter when its body contains errors
+// !WITH_NEW_INFERENCE
+
 package a
 
 fun <T, R: Comparable<R>> Iterable<T>._sortBy(<!UNUSED_PARAMETER!>f<!>: (T) -> R): List<T> = throw Exception()
@@ -7,5 +9,5 @@ fun <T> _arrayList(vararg <!UNUSED_PARAMETER!>values<!>: T) : List<T> = throw Ex
 class _Pair<A>(val a: A)
 
 fun test() {
-    _arrayList(_Pair(1))._sortBy { <!UNUSED_ANONYMOUS_PARAMETER!>it<!> -> <!UNRESOLVED_REFERENCE!>xxx<!> }
+    _arrayList(_Pair(1)).<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>_sortBy<!> { <!UNUSED_ANONYMOUS_PARAMETER!>it<!> -> <!UNRESOLVED_REFERENCE!>xxx<!> }
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2841.fir.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 package a
 
 interface Closeable {}

compiler/testData/diagnostics/tests/inference/regressions/kt2841.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 package a
 
 interface Closeable {}
@@ -8,7 +10,7 @@ public inline fun <T: Closeable, R> T.use1(block: (T)-> R) : R {
 }
 
 fun main() {
-    C().use1 {
+    C().<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>use1<!> {
         <!UNUSED_ANONYMOUS_PARAMETER!>w<!> ->  // ERROR here
         <!UNRESOLVED_REFERENCE!>x<!>
     }

compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.fir.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 package a
 
 interface Closeable {

compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 package a
 
 interface Closeable {
@@ -11,7 +13,7 @@ public inline fun <T: Closeable, R> T.use(block: (t: T)-> R) : R {
 }
 
 fun test() {
-    C().use {
+    C().<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>use<!> {
         it.close()
         <!UNRESOLVED_REFERENCE!>x<!>
     }

compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.fir.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 package a
 
 interface Closeable {

compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 package a
 
 interface Closeable {
@@ -11,7 +13,7 @@ public inline fun <T: Closeable, R> use(t: T, block: T.(T)-> R) : R {
 }
 
 fun test() {
-    use(C()) {
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>use<!>(C()) {
         this.close()
         it.close()
         <!UNRESOLVED_REFERENCE!>xx<!>

compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.fir.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 package a
 
 interface Closeable {

compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 package a
 
 interface Closeable {
@@ -11,7 +13,7 @@ public inline fun <T: Closeable, R> T.use(block: T.()-> R) : R {
 }
 
 fun test() {
-    C().use {
+    C().<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>use<!> {
         this.close()
         <!UNRESOLVED_REFERENCE!>x<!>
     }

compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.fir.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 package a
 
 interface Closeable {}

compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 package a
 
 interface Closeable {}
@@ -8,7 +10,7 @@ fun <T: Closeable, R> T.foo(block: (T)-> R) = block
 fun <T: Closeable, R> T.foo(block: (T, T)-> R) = block
 
 fun main() {
-    C().foo { // no ambiguity here
+    C().<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { // no ambiguity here
         <!UNUSED_ANONYMOUS_PARAMETER!>www<!> ->
         <!UNRESOLVED_REFERENCE!>xs<!>
     }

compiler/testData/diagnostics/tests/regressions/kt30245.kt

@@ -79,7 +79,7 @@ fun test2() { // to extension lambda 1
 //    val i27: E1 = id { i, s: String -> i + s.length } // overload oi- ni-
 
     val w28 = W2 <!TYPE_MISMATCH!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!EXPECTED_PARAMETER_TYPE_MISMATCH!>i: Int<!>, <!CANNOT_INFER_PARAMETER_TYPE!>s<!><!> -> i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>s<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>length<!> }<!> // oi- ni-
-    val i28: E1 = <!TYPE_MISMATCH!>id <!TYPE_MISMATCH!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!EXPECTED_PARAMETER_TYPE_MISMATCH!>i: Int<!>, <!CANNOT_INFER_PARAMETER_TYPE!>s<!><!> -> i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>s<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>length<!> }<!><!> // oi- ni-
+    val i28: E1 = id <!TYPE_MISMATCH!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!EXPECTED_PARAMETER_TYPE_MISMATCH!>i: Int<!>, <!CANNOT_INFER_PARAMETER_TYPE!>s<!><!> -> i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>s<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>length<!> }<!> // oi- ni-
     val w29 = W2 <!TYPE_MISMATCH!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!EXPECTED_PARAMETER_TYPE_MISMATCH!>i: Int<!>, s: String<!> -> i + s.length }<!> // oi- ni-
     val i29: E1 = id { i: Int, s: String -> i + s.length } // oi+ ni+
 

compiler/testData/diagnostics/tests/resolve/invoke/wrongInvokeExtension.fir.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 class B
 
 class A {

compiler/testData/diagnostics/tests/resolve/invoke/wrongInvokeExtension.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 class B
 
 class A {
@@ -11,7 +13,7 @@ fun test(a: A, b: B) {
 
     b.<!FUNCTION_EXPECTED!>(a)<!>()
 
-    with(b) {
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>with<!>(b) {
         val <!UNUSED_VARIABLE!>y<!>: Int = a()
         <!FUNCTION_EXPECTED!>(a)<!>()
     }

compiler/testData/diagnostics/tests/resolve/newLineLambda.kt

@@ -104,9 +104,9 @@ fun testTwoLambdas() {
             <!OI;TYPE_MISMATCH!>twoLambdaArgs({})
             {}
             <!MANY_LAMBDA_EXPRESSION_ARGUMENTS, UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{}<!><!>
-        } else {
+        } else <!NI;TYPE_MISMATCH!>{
             {}
-        }<!>
+        }<!><!>
     }
 }
 

compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.fir.kt

@@ -1,5 +1,6 @@
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
 
 // FILE: 2.kt
 package b

compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.kt

@@ -1,5 +1,6 @@
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
 
 // FILE: 2.kt
 package b
@@ -41,7 +42,7 @@ fun test(a: A) {
 
     a.<!OVERLOAD_RESOLUTION_AMBIGUITY!>forEach<!>("")
 
-    with(a) {
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>with<!>(a) {
         forEach() checkType { _<String>() }
 
         forEach(1) checkType { _<Int>() }

compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers2.fir.kt

@@ -1,5 +1,7 @@
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
 class A {
     fun forEach() = this
     fun forEach(i: Int) = this

compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers2.kt

@@ -1,5 +1,7 @@
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
 class A {
     fun forEach() = this
     fun forEach(i: Int) = this
@@ -35,7 +37,7 @@ fun test2(a: A) {
     a.forEach() checkType { _<String>() }
     a.<!OVERLOAD_RESOLUTION_AMBIGUITY!>forEach<!>(1)
 
-    with(a) {
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>with<!>(a) {
         forEach() checkType { _<String>() }
         <!OVERLOAD_RESOLUTION_AMBIGUITY!>forEach<!>(1)
     }

compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java

@@ -10378,6 +10378,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                     runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt");
                 }
 
+                @TestMetadata("coersionWithAnonymousFunctionsAndUnresolved.kt")
+                public void testCoersionWithAnonymousFunctionsAndUnresolved() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.kt");
+                }
+
                 @TestMetadata("indirectCoercionWithExpectedType.kt")
                 public void testIndirectCoercionWithExpectedType() throws Exception {
                     runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt");

compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java

@@ -10373,6 +10373,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                     runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt");
                 }
 
+                @TestMetadata("coersionWithAnonymousFunctionsAndUnresolved.kt")
+                public void testCoersionWithAnonymousFunctionsAndUnresolved() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.kt");
+                }
+
                 @TestMetadata("indirectCoercionWithExpectedType.kt")
                 public void testIndirectCoercionWithExpectedType() throws Exception {
                     runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt");

compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java

@@ -14715,11 +14715,6 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class NotNullAssertions extends AbstractLightAnalysisModeTest {
-            @TestMetadata("paramAssertionMessage.kt")
-            public void ignoreParamAssertionMessage() throws Exception {
-                runTest("compiler/testData/codegen/box/javaInterop/notNullAssertions/paramAssertionMessage.kt");
-            }
-
             private void runTest(String testDataFilePath) throws Exception {
                 KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
@@ -14808,6 +14803,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 runTest("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullableTypeParameter.kt");
             }
 
+            @TestMetadata("paramAssertionMessage.kt")
+            public void testParamAssertionMessage() throws Exception {
+                runTest("compiler/testData/codegen/box/javaInterop/notNullAssertions/paramAssertionMessage.kt");
+            }
+
             @TestMetadata("staticCallErrorMessage.kt")
             public void testStaticCallErrorMessage() throws Exception {
                 runTest("compiler/testData/codegen/box/javaInterop/notNullAssertions/staticCallErrorMessage.kt");

idea/src/org/jetbrains/kotlin/idea/inspections/collections/FunctionUtils.kt

@@ -73,7 +73,7 @@ fun ResolvedCall<*>.hasLastFunctionalParameterWithResult(context: BindingContext
     if (this is NewResolvedCallImpl<*>) {
         // TODO: looks like hack
         resolvedCallAtom.subResolvedAtoms?.firstOrNull { it is ResolvedLambdaAtom }.safeAs<ResolvedLambdaAtom>()?.let { lambdaAtom ->
-            return lambdaAtom.resultArguments.filterIsInstance<ReceiverKotlinCallArgument>().all {
+            return lambdaAtom.resultArgumentsInfo.nonErrorArguments.filterIsInstance<ReceiverKotlinCallArgument>().all {
                 val type = it.receiverValue?.type ?: return@all false
                 predicate(type)
             }