[FIR] Code cleanup: get rid of typeProvider hack

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt

@@ -128,7 +128,7 @@ class FirCallResolver(
             session,
             file,
             transformer.components.implicitReceiverStack
-        ) { it.resultType }
+        )
         towerResolver.reset()
 
         val consumer = createFunctionConsumer(session, name, info, this, towerResolver.collector, towerResolver)
@@ -165,7 +165,7 @@ class FirCallResolver(
             session,
             file,
             transformer.components.implicitReceiverStack
-        ) { it.resultType }
+        )
         towerResolver.reset()
 
         val consumer = createVariableAndObjectConsumer(
@@ -301,7 +301,7 @@ class FirCallResolver(
             session,
             file,
             implicitReceiverStack
-        ) { it.resultType }
+        )
         val candidateFactory = CandidateFactory(this, callInfo)
         val candidates = mutableListOf<Candidate>()
 
@@ -405,7 +405,7 @@ class FirCallResolver(
             expectedType,
             outerConstraintSystemBuilder,
             lhs
-        ) { it.resultType }
+        )
 
         return createCallableReferencesConsumer(session, name, info, this, resultCollector)
     }

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

@@ -41,8 +41,7 @@ fun Candidate.resolveArgumentExpression(
     sink: CheckerSink,
     isReceiver: Boolean,
     isDispatch: Boolean,
-    isSafeCall: Boolean,
+    isSafeCall: Boolean
-    typeProvider: (FirExpression) -> FirTypeRef?
 ) {
     return when (argument) {
         is FirFunctionCall, is FirWhenExpression, is FirTryExpression, is FirCheckNotNullCall -> resolveSubCallArgument(
@@ -52,8 +51,7 @@ fun Candidate.resolveArgumentExpression(
             sink,
             isReceiver,
             isDispatch,
-            isSafeCall,
+            isSafeCall
-            typeProvider
         )
         is FirCallableReferenceAccess ->
             if (argument.calleeReference is FirResolvedNamedReference)
@@ -64,8 +62,7 @@ fun Candidate.resolveArgumentExpression(
                     sink,
                     isReceiver,
                     isDispatch,
-                    isSafeCall,
+                    isSafeCall
-                    typeProvider
                 )
             else
                 preprocessCallableReference(argument, expectedType)
@@ -77,8 +74,7 @@ fun Candidate.resolveArgumentExpression(
             sink,
             isReceiver,
             isDispatch,
-            isSafeCall,
+            isSafeCall
-            typeProvider
         )
         // TODO:!
         is FirAnonymousFunction -> preprocessLambdaArgument(csBuilder, argument, expectedType, expectedTypeRef)
@@ -92,8 +88,7 @@ fun Candidate.resolveArgumentExpression(
             sink,
             isReceiver,
             isDispatch,
-            isSafeCall,
+            isSafeCall
-            typeProvider
         )
         is FirBlock -> resolveBlockArgument(
             csBuilder,
@@ -103,10 +98,9 @@ fun Candidate.resolveArgumentExpression(
             sink,
             isReceiver,
             isDispatch,
-            isSafeCall,
+            isSafeCall
-            typeProvider
         )
-        else -> resolvePlainExpressionArgument(csBuilder, argument, expectedType, sink, isReceiver, isDispatch, isSafeCall, typeProvider)
+        else -> resolvePlainExpressionArgument(csBuilder, argument, expectedType, sink, isReceiver, isDispatch, isSafeCall)
     }
 }
 
@@ -118,8 +112,7 @@ private fun Candidate.resolveBlockArgument(
     sink: CheckerSink,
     isReceiver: Boolean,
     isDispatch: Boolean,
-    isSafeCall: Boolean,
+    isSafeCall: Boolean
-    typeProvider: (FirExpression) -> FirTypeRef?
 ) {
     val returnArguments = block.returnExpressions()
     if (returnArguments.isEmpty()) {
@@ -144,8 +137,7 @@ private fun Candidate.resolveBlockArgument(
             sink,
             isReceiver,
             isDispatch,
-            isSafeCall,
+            isSafeCall
-            typeProvider
         )
     }
 }
@@ -157,8 +149,7 @@ fun Candidate.resolveSubCallArgument(
     sink: CheckerSink,
     isReceiver: Boolean,
     isDispatch: Boolean,
-    isSafeCall: Boolean,
+    isSafeCall: Boolean
-    typeProvider: (FirExpression) -> FirTypeRef?
 ) {
     val candidate = argument.candidate() ?: return resolvePlainExpressionArgument(
         csBuilder,
@@ -167,8 +158,7 @@ fun Candidate.resolveSubCallArgument(
         sink,
         isReceiver,
         isDispatch,
-        isSafeCall,
+        isSafeCall
-        typeProvider
     )
     /*
      * It's important to extract type from argument neither from symbol, because of symbol contains
@@ -190,11 +180,10 @@ fun Candidate.resolvePlainExpressionArgument(
     sink: CheckerSink,
     isReceiver: Boolean,
     isDispatch: Boolean,
-    isSafeCall: Boolean,
+    isSafeCall: Boolean
-    typeProvider: (FirExpression) -> FirTypeRef?
 ) {
     if (expectedType == null) return
-    val argumentType = typeProvider(argument)?.coneTypeSafe<ConeKotlinType>() ?: return
+    val argumentType = argument.typeRef.coneTypeSafe<ConeKotlinType>() ?: return
     resolvePlainArgumentType(csBuilder, argumentType, expectedType, sink, isReceiver, isDispatch, isSafeCall)
     checkApplicabilityForIntegerOperatorCall(sink, argument)
 }
@@ -276,7 +265,6 @@ internal fun Candidate.resolveArgument(
     parameter: FirValueParameter,
     isReceiver: Boolean,
     isSafeCall: Boolean,
-    typeProvider: (FirExpression) -> FirTypeRef?,
     sink: CheckerSink
 ) {
 
@@ -289,8 +277,7 @@ internal fun Candidate.resolveArgument(
         sink,
         isReceiver,
         false,
-        isSafeCall,
+        isSafeCall
-        typeProvider
     )
 }
 

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

@@ -40,9 +40,7 @@ class CallInfo(
     // Three properties for callable references only
     val expectedType: ConeKotlinType? = null,
     val outerCSBuilder: ConstraintSystemBuilder? = null,
-    val lhs: DoubleColonLHS? = null,
+    val lhs: DoubleColonLHS? = null
-
-    val typeProvider: (FirExpression) -> FirTypeRef?
 ) {
     val argumentCount get() = arguments.size
 

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

@@ -113,8 +113,7 @@ class InvokeReceiverCandidateCollector(
                 invokeCallInfo.implicitReceiverStack,
                 invokeCallInfo.expectedType,
                 invokeCallInfo.outerCSBuilder,
-                invokeCallInfo.lhs,
+                invokeCallInfo.lhs
-                invokeCallInfo.typeProvider
             ).let {
                 if (useExtensionReceiverAsArgument) it.withReceiverAsArgument(extensionReceiverExpression)
                 else it

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

@@ -74,8 +74,7 @@ fun createFunctionConsumer(
         callInfo.implicitReceiverStack,
         callInfo.expectedType,
         callInfo.outerCSBuilder,
-        callInfo.lhs,
+        callInfo.lhs
-        callInfo.typeProvider
     )
     return PrioritizedTowerDataConsumer(
         resultCollector,
@@ -117,7 +116,7 @@ fun createSimpleConsumer(
     val factory = CandidateFactory(bodyResolveComponents, callInfo)
     val explicitReceiver = callInfo.explicitReceiver
     return if (explicitReceiver != null) {
-        val receiverValue = ExpressionReceiverValue(explicitReceiver, callInfo.typeProvider)
+        val receiverValue = ExpressionReceiverValue(explicitReceiver)
         if (explicitReceiver is FirResolvedQualifier) {
             val qualified =
                 QualifiedReceiverTowerDataConsumer(session, name, token, receiverValue, factory, resultCollector)

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

@@ -46,11 +46,10 @@ class ClassDispatchReceiverValue(val klassSymbol: FirClassSymbol<*>) : ReceiverV
 }
 
 class ExpressionReceiverValue(
-    val explicitReceiverExpression: FirExpression,
+    val explicitReceiverExpression: FirExpression
-    val typeProvider: (FirExpression) -> FirTypeRef?
 ) : ReceiverValue {
     override val type: ConeKotlinType
-        get() = typeProvider(explicitReceiverExpression)?.coneTypeSafe()
+        get() = explicitReceiverExpression.typeRef.coneTypeSafe()
             ?: ConeKotlinErrorType("No type calculated for: ${explicitReceiverExpression.renderWithType()}") // TODO: assert here
 
     override val receiverExpression: FirExpression

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
 import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedReferenceError
 import org.jetbrains.kotlin.fir.resolve.transformers.StoreNameReference
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
-import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.resolve.calls.components.InferenceSession
 import org.jetbrains.kotlin.resolve.calls.components.PostponedArgumentsAnalyzer
@@ -39,7 +38,6 @@ interface LambdaAnalyzer {
 
 class PostponedArgumentsAnalyzer(
     private val lambdaAnalyzer: LambdaAnalyzer,
-    private val typeProvider: (FirExpression) -> FirTypeRef?,
     private val components: InferenceComponents,
     private val candidate: Candidate,
     private val replacements: MutableMap<FirExpression, FirExpression>,
@@ -148,8 +146,7 @@ class PostponedArgumentsAnalyzer(
                 checkerSink,
                 isReceiver = false,
                 isDispatch = false,
-                isSafeCall = false,
+                isSafeCall = false
-                typeProvider = typeProvider
             )
 //            resolveKtPrimitive(
 //                c.getBuilder(), it, lambda.returnType.let(::substitute), diagnosticHolder, isReceiver = false

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

@@ -110,8 +110,7 @@ internal sealed class CheckReceivers : ResolutionStage() {
                     sink = sink,
                     isReceiver = true,
                     isDispatch = this is Dispatch,
-                    isSafeCall = callInfo.isSafeCall,
+                    isSafeCall = callInfo.isSafeCall
-                    typeProvider = callInfo.typeProvider
                 )
                 sink.yieldIfNeed()
             } else {
@@ -156,7 +155,6 @@ internal object CheckArguments : CheckerStage() {
                 parameter,
                 isReceiver = false,
                 isSafeCall = false,
-                typeProvider = callInfo.typeProvider,
                 sink = sink
             )
             if (candidate.system.hasContradiction) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt

@@ -79,7 +79,7 @@ class FirCallCompleter(
 
         val analyzer =
             PostponedArgumentsAnalyzer(
-                LambdaAnalyzerImpl(replacements), { it.resultType }, inferenceComponents, candidate, replacements,
+                LambdaAnalyzerImpl(replacements), inferenceComponents, candidate, replacements,
                 transformer.components.callResolver
             )
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.calls.*
 import org.jetbrains.kotlin.fir.resolve.inference.FirCallCompleter
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
 import org.jetbrains.kotlin.fir.resolve.withNullability
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.SyntheticCallableId
@@ -146,7 +145,7 @@ class FirSyntheticCallGenerator(
         session = session,
         containingFile = file,
         implicitReceiverStack = implicitReceiverStack
-    ) { it.resultType }
+    )
 
     private fun generateSyntheticSelectFunction(callableId: CallableId): FirSimpleFunctionImpl {
         // Synthetic function signature: