[FIR] Introduce ResolutionMode as data for body resolve instead of Any?

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

@@ -66,8 +66,8 @@ class FirCallResolver(
     fun resolveCallAndSelectCandidate(functionCall: FirFunctionCall, expectedTypeRef: FirTypeRef?, file: FirFile): FirFunctionCall {
         qualifiedResolver.reset()
         @Suppress("NAME_SHADOWING")
-        val functionCall = functionCall.transformExplicitReceiver(transformer, noExpectedType)
+        val functionCall = functionCall.transformExplicitReceiver(transformer, ResolutionMode.ContextIndependent)
-            .transformArguments(transformer, null)
+            .transformArguments(transformer, ResolutionMode.ContextDependent)
 
         val name = functionCall.calleeReference.name
 
@@ -161,7 +161,7 @@ class FirCallResolver(
         qualifiedResolver.initProcessingQualifiedAccess(qualifiedAccess, callee)
 
         @Suppress("NAME_SHADOWING")
-        val qualifiedAccess = qualifiedAccess.transformExplicitReceiver(transformer, noExpectedType)
+        val qualifiedAccess = qualifiedAccess.transformExplicitReceiver(transformer, ResolutionMode.ContextIndependent)
         qualifiedResolver.replacedQualifier(qualifiedAccess)?.let { return it }
 
         val info = CallInfo(

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

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.resolve
+
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+
+sealed class ResolutionMode {
+    object ContextDependent : ResolutionMode()
+    object ContextIndependent : ResolutionMode()
+    class WithExpectedType(val expectedTypeRef: FirTypeRef) : ResolutionMode()
+    class LambdaResolution(val expectedReturnTypeRef: FirResolvedTypeRef?) : ResolutionMode()
+}
+
+fun withExpectedType(expectedTypeRef: FirTypeRef?): ResolutionMode =
+    expectedTypeRef?.let { ResolutionMode.WithExpectedType(it) } ?: ResolutionMode.ContextDependent

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.ImplicitReceiverStackImpl
+import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.dfa.Condition.*
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.*
 import org.jetbrains.kotlin.fir.resolve.dfa.contracts.buildContractFir
@@ -485,7 +486,7 @@ class FirDataFlowAnalyzer(private val components: FirAbstractBodyResolveTransfor
         for (conditionalEffect in conditionalEffects) {
             val fir = conditionalEffect.buildContractFir(argumentsMapping) ?: continue
             val effect = conditionalEffect.effect as? ConeReturnsEffectDeclaration ?: continue
-            fir.transformSingle(components.transformer, null)
+            fir.transformSingle(components.transformer, ResolutionMode.ContextDependent)
             val argumentVariable = getOrCreateVariable(fir)
             val lastNode = graphBuilder.lastNode
             when (val value = effect.value) {

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirResolvable
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
+import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.calls.*
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.transformers.FirCallCompletionResultsWriterTransformer
@@ -141,7 +142,7 @@ class FirCallCompleter(
             )
 
             replacements[lambdaArgument] =
-                newLambdaExpression.transformSingle(transformer, FirDeclarationsResolveTransformer.LambdaResolution(expectedReturnTypeRef))
+                newLambdaExpression.transformSingle(transformer, ResolutionMode.LambdaResolution(expectedReturnTypeRef))
 
             return (newLambdaExpression.body?.returnExpressions() ?: emptyList()) to InferenceSession.default
         }

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

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformer
@@ -84,7 +85,7 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc
             scopeSession
         )
 
-        file.transform<FirElement, Any?>(transformer, null)
+        file.transform<FirElement, ResolutionMode>(transformer, ResolutionMode.ContextDependent)
 
 
         val newReturnTypeRef = declaration.returnTypeRef

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 
-abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAbstractPhaseTransformer<Any?>(phase) {
+abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAbstractPhaseTransformer<ResolutionMode>(phase) {
     abstract val components: BodyResolveTransformerComponents
 
     abstract var implicitTypeOnly: Boolean
@@ -78,6 +78,13 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb
     protected inline val scopeSession: ScopeSession get() = components.scopeSession
     protected inline val file: FirFile get() = components.file
 
+    val ResolutionMode.expectedType: FirTypeRef?
+        get() = when (this) {
+            is ResolutionMode.WithExpectedType -> expectedTypeRef
+            is ResolutionMode.ContextIndependent -> noExpectedType
+            else -> null
+        }
+
     class BodyResolveTransformerComponents(
         override val session: FirSession,
         override val scopeSession: ScopeSession,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirTargetElement
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.scopes.addImportingScopes
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
@@ -34,7 +35,7 @@ open class FirBodyResolveTransformer(
     private val declarationsTransformer = FirDeclarationsResolveTransformer(this)
     private val controlFlowStatementsTransformer = FirControlFlowStatementsResolveTransformer(this)
 
-    override fun transformFile(file: FirFile, data: Any?): CompositeTransformResult<FirFile> {
+    override fun transformFile(file: FirFile, data: ResolutionMode): CompositeTransformResult<FirFile> {
         packageFqName = file.packageFqName
         components.file = file
         return withScopeCleanup(components.topLevelScopes) {
@@ -44,181 +45,180 @@ open class FirBodyResolveTransformer(
         }
     }
 
-    override fun <E : FirElement> transformElement(element: E, data: Any?): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): CompositeTransformResult<E> {
         @Suppress("UNCHECKED_CAST")
         return (element.transformChildren(this, data) as E).compose()
     }
 
-    override fun transformTypeRef(typeRef: FirTypeRef, data: Any?): CompositeTransformResult<FirTypeRef> {
+    override fun transformTypeRef(typeRef: FirTypeRef, data: ResolutionMode): CompositeTransformResult<FirTypeRef> {
         return typeRef.compose()
     }
 
-    override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Any?): CompositeTransformResult<FirTypeRef> {
+    override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: ResolutionMode): CompositeTransformResult<FirTypeRef> {
-        if (data == null)
+        if (data !is ResolutionMode.WithExpectedType)
             return implicitTypeRef.compose()
-        require(data is FirTypeRef)
+        return data.expectedTypeRef.compose()
-        return data.compose()
     }
 
     // ------------------------------------- Expressions -------------------------------------
 
-    override fun transformExpression(expression: FirExpression, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformExpression(expression, data)
     }
 
     override fun transformQualifiedAccessExpression(
         qualifiedAccessExpression: FirQualifiedAccessExpression,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformQualifiedAccessExpression(qualifiedAccessExpression, data)
     }
 
-    override fun transformFunctionCall(functionCall: FirFunctionCall, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformFunctionCall(functionCall, data)
     }
 
     override fun transformCallableReferenceAccess(
         callableReferenceAccess: FirCallableReferenceAccess,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformCallableReferenceAccess(callableReferenceAccess, data)
     }
 
-    override fun transformBlock(block: FirBlock, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformBlock(block, data)
     }
 
     override fun transformThisReceiverExpression(
         thisReceiverExpression: FirThisReceiverExpression,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformThisReceiverExpression(thisReceiverExpression, data)
     }
 
-    override fun transformOperatorCall(operatorCall: FirOperatorCall, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformOperatorCall(operatorCall: FirOperatorCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformOperatorCall(operatorCall, data)
     }
 
-    override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformTypeOperatorCall(typeOperatorCall, data)
     }
 
     override fun transformBinaryLogicExpression(
         binaryLogicExpression: FirBinaryLogicExpression,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformBinaryLogicExpression(binaryLogicExpression, data)
     }
 
     override fun transformVariableAssignment(
         variableAssignment: FirVariableAssignment,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformVariableAssignment(variableAssignment, data)
     }
 
-    override fun transformGetClassCall(getClassCall: FirGetClassCall, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformGetClassCall(getClassCall, data)
     }
 
     override fun transformWrappedDelegateExpression(
         wrappedDelegateExpression: FirWrappedDelegateExpression,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformWrappedDelegateExpression(wrappedDelegateExpression, data)
     }
 
-    override fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformConstExpression(constExpression, data)
     }
 
-    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return expressionsTransformer.transformAnnotationCall(annotationCall, data)
     }
 
     // ------------------------------------- Declarations -------------------------------------
 
-    override fun transformDeclaration(declaration: FirDeclaration, data: Any?): CompositeTransformResult<FirDeclaration> {
+    override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
         return declarationsTransformer.transformDeclaration(declaration, data)
     }
 
-    override fun transformProperty(property: FirProperty, data: Any?): CompositeTransformResult<FirDeclaration> {
+    override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
         return declarationsTransformer.transformProperty(property, data)
     }
 
-    override fun transformRegularClass(regularClass: FirRegularClass, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return declarationsTransformer.transformRegularClass(regularClass, data)
     }
 
-    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return declarationsTransformer.transformAnonymousObject(anonymousObject, data)
     }
 
-    override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?): CompositeTransformResult<FirDeclaration> {
+    override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
         return declarationsTransformer.transformSimpleFunction(simpleFunction, data)
     }
 
-    override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return declarationsTransformer.transformFunction(function, data)
     }
 
-    override fun transformConstructor(constructor: FirConstructor, data: Any?): CompositeTransformResult<FirDeclaration> {
+    override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
         return declarationsTransformer.transformConstructor(constructor, data)
     }
 
     override fun transformAnonymousInitializer(
         anonymousInitializer: FirAnonymousInitializer,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirDeclaration> {
         return declarationsTransformer.transformAnonymousInitializer(anonymousInitializer, data)
     }
 
-    override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return declarationsTransformer.transformAnonymousFunction(anonymousFunction, data)
     }
 
-    override fun transformValueParameter(valueParameter: FirValueParameter, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return declarationsTransformer.transformValueParameter(valueParameter, data)
     }
 
     // ------------------------------------- Control flow statements -------------------------------------
 
-    override fun transformWhileLoop(whileLoop: FirWhileLoop, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return controlFlowStatementsTransformer.transformWhileLoop(whileLoop, data)
     }
 
-    override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return controlFlowStatementsTransformer.transformDoWhileLoop(doWhileLoop, data)
     }
 
-    override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return controlFlowStatementsTransformer.transformWhenExpression(whenExpression, data)
     }
 
-    override fun transformWhenBranch(whenBranch: FirWhenBranch, data: Any?): CompositeTransformResult<FirWhenBranch> {
+    override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): CompositeTransformResult<FirWhenBranch> {
         return controlFlowStatementsTransformer.transformWhenBranch(whenBranch, data)
     }
 
     override fun transformWhenSubjectExpression(
         whenSubjectExpression: FirWhenSubjectExpression,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         return controlFlowStatementsTransformer.transformWhenSubjectExpression(whenSubjectExpression, data)
     }
 
-    override fun transformTryExpression(tryExpression: FirTryExpression, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return controlFlowStatementsTransformer.transformTryExpression(tryExpression, data)
     }
 
-    override fun transformCatch(catch: FirCatch, data: Any?): CompositeTransformResult<FirCatch> {
+    override fun transformCatch(catch: FirCatch, data: ResolutionMode): CompositeTransformResult<FirCatch> {
         return controlFlowStatementsTransformer.transformCatch(catch, data)
     }
 
-    override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return controlFlowStatementsTransformer.transformJump(jump, data)
     }
 
-    override fun transformThrowExpression(throwExpression: FirThrowExpression, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformThrowExpression(throwExpression: FirThrowExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return controlFlowStatementsTransformer.transformThrowExpression(throwExpression, data)
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformerAdapters.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -26,7 +27,7 @@ class FirDesignatedBodyResolveTransformer(
     implicitTypeOnly = implicitTypeOnly,
     scopeSession = scopeSession
 ) {
-    override fun <E : FirElement> transformElement(element: E, data: Any?): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): CompositeTransformResult<E> {
         if (designation.hasNext()) {
             designation.next().visitNoTransform(this, data)
             return element.compose()
@@ -34,7 +35,7 @@ class FirDesignatedBodyResolveTransformer(
         return super.transformElement(element, data)
     }
 
-    override fun transformDeclaration(declaration: FirDeclaration, data: Any?): CompositeTransformResult<FirDeclaration> {
+    override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
         return components.withContainer(declaration) {
             declaration.replaceResolvePhase(transformerPhase)
             transformElement(declaration, data)
@@ -58,7 +59,7 @@ class FirImplicitTypeBodyResolveTransformerAdapter : FirTransformer<Nothing?>()
             implicitTypeOnly = true,
             scopeSession = scopeSession
         )
-        return file.transform(transformer, null)
+        return file.transform(transformer, ResolutionMode.ContextDependent)
     }
 }
 
@@ -79,6 +80,6 @@ class FirBodyResolveTransformerAdapter : FirTransformer<Nothing?>() {
             implicitTypeOnly = false,
             scopeSession = scopeSession
         )
-        return file.transform(transformer, null)
+        return file.transform(transformer, ResolutionMode.ContextDependent)
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt

@@ -12,12 +12,12 @@ import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
 import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyExpressionBlock
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.transformers.FirSyntheticCallGenerator
 import org.jetbrains.kotlin.fir.resolve.transformers.FirWhenExhaustivenessTransformer
 import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
 import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
-import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.compose
@@ -32,14 +32,14 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
 
     // ------------------------------- Loops -------------------------------
 
-    override fun transformWhileLoop(whileLoop: FirWhileLoop, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return whileLoop.also(dataFlowAnalyzer::enterWhileLoop)
             .transformCondition(transformer, data).also(dataFlowAnalyzer::exitWhileLoopCondition)
             .transformBlock(transformer, data).also(dataFlowAnalyzer::exitWhileLoop)
             .transformOtherChildren(transformer, data).compose()
     }
 
-    override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return doWhileLoop.also(dataFlowAnalyzer::enterDoWhileLoop)
             .transformBlock(transformer, data).also(dataFlowAnalyzer::enterDoWhileLoopCondition)
             .transformCondition(transformer, data).also(dataFlowAnalyzer::exitDoWhileLoop)
@@ -48,7 +48,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
 
     // ------------------------------- When expressions -------------------------------
 
-    override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         if (whenExpression.calleeReference is FirResolvedNamedReference && whenExpression.resultType !is FirImplicitTypeRef) {
             return whenExpression.compose()
         }
@@ -58,17 +58,17 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
                 localScopes += FirLocalScope()
             }
             @Suppress("NAME_SHADOWING")
-            var whenExpression = whenExpression.transformSubject(transformer, noExpectedType)
+            var whenExpression = whenExpression.transformSubject(transformer, ResolutionMode.ContextIndependent)
 
             when {
                 whenExpression.branches.isEmpty() -> {
                 }
                 whenExpression.isOneBranch() -> {
-                    whenExpression = whenExpression.transformBranches(transformer, noExpectedType)
+                    whenExpression = whenExpression.transformBranches(transformer, ResolutionMode.ContextIndependent)
                     whenExpression.resultType = whenExpression.branches.first().result.resultType
                 }
                 else -> {
-                    whenExpression = whenExpression.transformBranches(transformer, null)
+                    whenExpression = whenExpression.transformBranches(transformer, ResolutionMode.ContextDependent)
 
                     whenExpression = syntheticCallGenerator.generateCalleeForWhenExpression(whenExpression) ?: run {
                         whenExpression = whenExpression.transformSingle(whenExhaustivenessTransformer, null)
@@ -77,7 +77,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
                         return@with whenExpression.compose()
                     }
 
-                    val expectedTypeRef = data as FirTypeRef?
+                    val expectedTypeRef = data.expectedType
                     whenExpression = callCompleter.completeCall(whenExpression, expectedTypeRef)
                 }
             }
@@ -102,7 +102,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
         return lastBranch.condition is FirElseIfTrueCondition && lastBranch.result is FirEmptyExpressionBlock
     }
 
-    override fun transformWhenBranch(whenBranch: FirWhenBranch, data: Any?): CompositeTransformResult<FirWhenBranch> {
+    override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): CompositeTransformResult<FirWhenBranch> {
         return whenBranch.also { dataFlowAnalyzer.enterWhenBranchCondition(whenBranch) }
             .transformCondition(transformer, data).also { dataFlowAnalyzer.exitWhenBranchCondition(it) }
             .transformResult(transformer, data).also { dataFlowAnalyzer.exitWhenBranchResult(it) }
@@ -111,7 +111,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
 
     override fun transformWhenSubjectExpression(
         whenSubjectExpression: FirWhenSubjectExpression,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         val parentWhen = whenSubjectExpression.whenSubject.whenExpression
         val subjectType = parentWhen.subject?.resultType ?: parentWhen.subjectVariable?.returnTypeRef
@@ -123,19 +123,19 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
 
     // ------------------------------- Try/catch expressions -------------------------------
 
-    override fun transformTryExpression(tryExpression: FirTryExpression, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         if (tryExpression.calleeReference is FirResolvedNamedReference && tryExpression.resultType !is FirImplicitTypeRef) {
             return tryExpression.compose()
         }
 
         dataFlowAnalyzer.enterTryExpression(tryExpression)
-        tryExpression.transformTryBlock(transformer, null)
+        tryExpression.transformTryBlock(transformer, ResolutionMode.ContextDependent)
         dataFlowAnalyzer.exitTryMainBlock(tryExpression)
-        tryExpression.transformCatches(this, null)
+        tryExpression.transformCatches(this, ResolutionMode.ContextDependent)
 
         @Suppress("NAME_SHADOWING")
         var result = syntheticCallGenerator.generateCalleeForTryExpression(tryExpression)?.let {
-            val expectedTypeRef = data as FirTypeRef?
+            val expectedTypeRef = data.expectedType
             callCompleter.completeCall(it, expectedTypeRef)
         } ?: run {
             tryExpression.resultType = FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Can't resolve try expression", DiagnosticKind.InferenceError))
@@ -144,7 +144,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
 
         result = if (result.finallyBlock != null) {
             result.also(dataFlowAnalyzer::enterFinallyBlock)
-                .transformFinallyBlock(transformer, noExpectedType)
+                .transformFinallyBlock(transformer, ResolutionMode.ContextIndependent)
                 .also(dataFlowAnalyzer::exitFinallyBlock)
         } else {
             result
@@ -153,24 +153,24 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
         return result.compose()
     }
 
-    override fun transformCatch(catch: FirCatch, data: Any?): CompositeTransformResult<FirCatch> {
+    override fun transformCatch(catch: FirCatch, data: ResolutionMode): CompositeTransformResult<FirCatch> {
         dataFlowAnalyzer.enterCatchClause(catch)
         return withScopeCleanup(localScopes) {
             localScopes += FirLocalScope()
-            catch.transformParameter(transformer, noExpectedType)
+            catch.transformParameter(transformer, ResolutionMode.ContextIndependent)
-            catch.transformBlock(transformer, null)
+            catch.transformBlock(transformer, ResolutionMode.ContextDependent)
         }.also { dataFlowAnalyzer.exitCatchClause(it) }.compose()
     }
 
     // ------------------------------- Jumps -------------------------------
 
-    override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         val result = transformer.transformExpression(jump, data)
         dataFlowAnalyzer.exitJump(jump)
         return result
     }
 
-    override fun transformThrowExpression(throwExpression: FirThrowExpression, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformThrowExpression(throwExpression: FirThrowExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return transformer.transformExpression(throwExpression, data).also {
             dataFlowAnalyzer.exitThrowExceptionNode(it.single as FirThrowExpression)
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirStatement
+import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.calls.ImplicitDispatchReceiverValue
 import org.jetbrains.kotlin.fir.resolve.calls.ImplicitExtensionReceiverValue
 import org.jetbrains.kotlin.fir.resolve.calls.extractLambdaInfoFromFunctionalType
@@ -20,6 +21,7 @@ import org.jetbrains.kotlin.fir.resolve.constructFunctionalTypeRef
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.resolve.transformers.ControlFlowGraphReferenceTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.StoreType
+import org.jetbrains.kotlin.fir.resolve.withExpectedType
 import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
 import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
@@ -36,14 +38,14 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) : FirPartialBodyResolveTransformer(transformer) {
     private var primaryConstructorParametersScope: FirLocalScope? = null
 
-    override fun transformDeclaration(declaration: FirDeclaration, data: Any?): CompositeTransformResult<FirDeclaration> {
+    override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
         return components.withContainer(declaration) {
             declaration.replaceResolvePhase(transformerPhase)
             transformer.transformElement(declaration, data)
         }
     }
 
-    override fun transformProperty(property: FirProperty, data: Any?): CompositeTransformResult<FirDeclaration> {
+    override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
         if (property.isLocal) return transformLocalVariable(property, data)
         val returnTypeRef = property.returnTypeRef
         if (returnTypeRef !is FirImplicitTypeRef && implicitTypeOnly) return property.compose()
@@ -75,9 +77,9 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
         }
     }
 
-    private fun transformLocalVariable(variable: FirProperty, data: Any?): CompositeTransformResult<FirDeclaration> {
+    private fun transformLocalVariable(variable: FirProperty, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
         assert(variable.isLocal)
-        variable.transformOtherChildren(transformer, variable.returnTypeRef)
+        variable.transformOtherChildren(transformer, withExpectedType(variable.returnTypeRef))
         if (variable.initializer != null) {
             storeVariableReturnType(variable)
         }
@@ -89,8 +91,8 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
     }
 
     private fun FirProperty.transformChildrenWithoutAccessors(returnTypeRef: FirTypeRef): FirProperty {
-        return transformReturnTypeRef(transformer, returnTypeRef).
+        val data = withExpectedType(returnTypeRef)
-            transformOtherChildren(transformer, returnTypeRef)
+        return transformReturnTypeRef(transformer, data).transformOtherChildren(transformer, data)
     }
 
     private fun <F : FirVariable<F>> FirVariable<F>.transformAccessors() {
@@ -114,7 +116,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
         owner: FirVariable<*>
     ) {
         if (accessor is FirDefaultPropertyAccessor || accessor.body == null) {
-            transformFunction(accessor, enhancedTypeRef)
+            transformFunction(accessor, withExpectedType(enhancedTypeRef))
         }
         val returnTypeRef = accessor.returnTypeRef
         if (returnTypeRef is FirImplicitTypeRef && enhancedTypeRef !is FirResolvedTypeRef) {
@@ -135,7 +137,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
         } as CompositeTransformResult<FirStatement>
     }
 
-    override fun transformRegularClass(regularClass: FirRegularClass, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         localScopes.lastOrNull()?.storeDeclaration(regularClass)
         val oldConstructorScope = primaryConstructorParametersScope
         primaryConstructorParametersScope = null
@@ -153,7 +155,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
         return result as CompositeTransformResult<FirStatement>
     }
 
-    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         val type = anonymousObject.defaultType()
         anonymousObject.resultType = FirResolvedTypeRefImpl(anonymousObject.source, type)
         val result = withLabelAndReceiverType(null, anonymousObject, type) {
@@ -163,16 +165,16 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
     }
 
     private fun transformAnonymousFunctionWithLambdaResolution(
-        anonymousFunction: FirAnonymousFunction, lambdaResolution: LambdaResolution
+        anonymousFunction: FirAnonymousFunction, lambdaResolution: ResolutionMode.LambdaResolution
     ): FirAnonymousFunction {
         val receiverTypeRef = anonymousFunction.receiverTypeRef
         fun transform(): FirAnonymousFunction {
             val expectedReturnType =
                 lambdaResolution.expectedReturnTypeRef ?: anonymousFunction.returnTypeRef.takeUnless { it is FirImplicitTypeRef }
-            val result = transformFunction(anonymousFunction, expectedReturnType).single as FirAnonymousFunction
+            val result = transformFunction(anonymousFunction, withExpectedType(expectedReturnType)).single as FirAnonymousFunction
             val body = result.body
             return if (result.returnTypeRef is FirImplicitTypeRef && body != null) {
-                result.transformReturnTypeRef(transformer, body.resultType)
+                result.transformReturnTypeRef(transformer, withExpectedType(body.resultType))
                 result
             } else {
                 result
@@ -189,9 +191,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
         }
     }
 
-    data class LambdaResolution(val expectedReturnTypeRef: FirResolvedTypeRef?)
+    override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
-
-    override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?): CompositeTransformResult<FirDeclaration> {
         val returnTypeRef = simpleFunction.returnTypeRef
         if ((returnTypeRef !is FirImplicitTypeRef) && implicitTypeOnly) {
             return simpleFunction.compose()
@@ -219,17 +219,17 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
         if (function is FirSimpleFunction) {
             localScopes.lastOrNull()?.storeDeclaration(function)
         }
-        val result = transformFunction(function, returnTypeRef).single as FirFunction<*>
+        val result = transformFunction(function, withExpectedType(returnTypeRef)).single as FirFunction<*>
         val body = result.body
         return if (result.returnTypeRef is FirImplicitTypeRef && body != null) {
-            result.transformReturnTypeRef(transformer, body.resultType)
+            result.transformReturnTypeRef(transformer, withExpectedType(body.resultType))
             result
         } else {
             result
         }.compose()
     }
 
-    override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return withScopeCleanup(localScopes) {
             localScopes += FirLocalScope()
             dataFlowAnalyzer.enterFunction(function)
@@ -242,14 +242,14 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
         }
     }
 
-    override fun transformConstructor(constructor: FirConstructor, data: Any?): CompositeTransformResult<FirDeclaration> {
+    override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
         if (implicitTypeOnly) return constructor.compose()
         return transformFunction(constructor, data) as CompositeTransformResult<FirDeclaration>
     }
 
     override fun transformAnonymousInitializer(
         anonymousInitializer: FirAnonymousInitializer,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirDeclaration> {
         if (implicitTypeOnly) return anonymousInitializer.compose()
         return withScopeCleanup(localScopes) {
@@ -261,25 +261,25 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
         }
     }
 
-    override fun transformValueParameter(valueParameter: FirValueParameter, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         localScopes.lastOrNull()?.storeDeclaration(valueParameter)
         if (valueParameter.returnTypeRef is FirImplicitTypeRef) {
             valueParameter.replaceResolvePhase(transformerPhase)
             return valueParameter.compose() // TODO
         }
-        return (transformDeclaration(valueParameter, valueParameter.returnTypeRef).single as FirStatement).compose()
+        return (transformDeclaration(valueParameter, withExpectedType(valueParameter.returnTypeRef)).single as FirStatement).compose()
     }
 
-    override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         return when (data) {
-            null -> {
+            ResolutionMode.ContextDependent -> {
                 anonymousFunction.compose()
             }
-            is LambdaResolution -> {
+            is ResolutionMode.LambdaResolution -> {
                 transformAnonymousFunctionWithLambdaResolution(anonymousFunction, data).compose()
             }
-            is FirTypeRef -> {
+            is ResolutionMode.WithExpectedType -> {
-                val resolvedLambdaAtom = (data as? FirResolvedTypeRef)?.let {
+                val resolvedLambdaAtom = (data.expectedTypeRef as? FirResolvedTypeRef)?.let {
                     extractLambdaInfoFromFunctionalType(
                         it.type, it, anonymousFunction
                     )
@@ -335,15 +335,15 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
                         ?: af.returnTypeRef
                 )
                 af = af.transformValueParameters(ImplicitToErrorTypeTransformer, null)
-                val bodyExpectedType = returnTypeRefFromResolvedAtom ?: data
+                val bodyExpectedType = returnTypeRefFromResolvedAtom ?: data.expectedTypeRef
-                af = transformFunction(af, bodyExpectedType).single as FirAnonymousFunction
+                af = transformFunction(af, withExpectedType(bodyExpectedType)).single as FirAnonymousFunction
                 af = af.copy(
                     returnTypeRef = af.body?.resultType ?: FirErrorTypeRefImpl(af.source, FirSimpleDiagnostic("No result type for lambda", DiagnosticKind.InferenceError))
                 )
                 af.replaceTypeRef(af.constructFunctionalTypeRef(session))
                 af.compose()
             }
-            else -> {
+            is ResolutionMode.ContextIndependent -> {
                 transformFunction(anonymousFunction, data).single.compose()
             }
         }
@@ -380,37 +380,39 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
         if (variable.returnTypeRef is FirImplicitTypeRef) {
             when {
                 initializer != null -> {
+                    val expectedType = when (val resultType = initializer.resultType) {
+                        is FirImplicitTypeRef -> FirErrorTypeRefImpl(
+                            null,
+                            FirSimpleDiagnostic("No result type for initializer", DiagnosticKind.InferenceError)
+                        )
+                        else -> resultType
+                    }
                     variable.transformReturnTypeRef(
                         transformer,
-                        when (val resultType = initializer.resultType) {
+                        withExpectedType(expectedType)
-                            is FirImplicitTypeRef -> FirErrorTypeRefImpl(
-                                null,
-                                FirSimpleDiagnostic("No result type for initializer", DiagnosticKind.InferenceError)
-                            )
-                            else -> resultType
-                        }
                     )
                 }
                 variable.getter != null && variable.getter !is FirDefaultPropertyAccessor -> {
+                    val expectedType = when (val resultType = variable.getter?.returnTypeRef) {
+                        is FirImplicitTypeRef -> FirErrorTypeRefImpl(
+                            null,
+                            FirSimpleDiagnostic("No result type for getter", DiagnosticKind.InferenceError)
+                        )
+                        else -> resultType
+                    }
                     variable.transformReturnTypeRef(
                         transformer,
-                        when (val resultType = variable.getter?.returnTypeRef) {
+                        withExpectedType(expectedType)
-                            is FirImplicitTypeRef -> FirErrorTypeRefImpl(
-                                null,
-                                FirSimpleDiagnostic("No result type for getter", DiagnosticKind.InferenceError)
-                            )
-                            else -> resultType
-                        }
                     )
                 }
                 else -> {
                     variable.transformReturnTypeRef(
-                        transformer, FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Cannot infer variable type without initializer / getter / delegate", DiagnosticKind.InferenceError))
+                        transformer, withExpectedType(FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Cannot infer variable type without initializer / getter / delegate", DiagnosticKind.InferenceError)))
                     )
                 }
             }
             if (variable.getter?.returnTypeRef is FirImplicitTypeRef) {
-                variable.getter?.transformReturnTypeRef(transformer, variable.returnTypeRef)
+                variable.getter?.transformReturnTypeRef(transformer, withExpectedType(variable.returnTypeRef))
             }
         }
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt

@@ -22,16 +22,13 @@ import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
 import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.ConeInferenceContext
 import org.jetbrains.kotlin.fir.resolve.calls.candidate
-import org.jetbrains.kotlin.fir.resolve.constructType
 import org.jetbrains.kotlin.fir.resolve.diagnostics.FirOperatorAmbiguityError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedReferenceError
-import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.InvocationKindTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.StoreReceiver
-import org.jetbrains.kotlin.fir.resolve.typeFromCallee
-import org.jetbrains.kotlin.fir.resolve.withNullability
 import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
 import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
@@ -57,7 +54,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         components.callResolver.initTransformer(this)
     }
 
-    override fun transformExpression(expression: FirExpression, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) {
             val type = FirErrorTypeRefImpl(expression.source, FirSimpleDiagnostic("Type calculating for ${expression::class} is not supported", DiagnosticKind.InferenceError))
             expression.resultType = type
@@ -67,7 +64,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformQualifiedAccessExpression(
         qualifiedAccessExpression: FirQualifiedAccessExpression,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         var result = when (val callee = qualifiedAccessExpression.calleeReference) {
             is FirExplicitThisReference -> {
@@ -109,7 +106,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                 // NB: here we can get raw expression because of dropped qualifiers (see transform callee),
                 // so candidate existence must be checked before calling completion
                 if (transformedCallee is FirQualifiedAccessExpression && transformedCallee.candidate() != null) {
-                    callCompleter.completeCall(transformedCallee, data as? FirTypeRef)
+                    callCompleter.completeCall(transformedCallee, data.expectedType)
                 } else {
                     transformedCallee
                 }
@@ -135,14 +132,14 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         return FirExpressionWithSmartcastImpl(qualifiedAccessExpression, intersectedTypeRef, typesFromSmartCast)
     }
 
-    override fun transformFunctionCall(functionCall: FirFunctionCall, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         if (functionCall.calleeReference is FirResolvedNamedReference && functionCall.resultType is FirImplicitTypeRef) {
             storeTypeFromCallee(functionCall)
         }
         dataFlowAnalyzer.enterFunctionCall(functionCall)
         if (functionCall.calleeReference !is FirSimpleNamedReference) return functionCall.compose()
         functionCall.transform<FirFunctionCall, Nothing?>(InvocationKindTransformer, null)
-        val expectedTypeRef = data as FirTypeRef?
+        val expectedTypeRef = data.expectedType
         val completeInference =
             try {
                 val initialExplicitReceiver = functionCall.explicitReceiver
@@ -161,7 +158,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         return completeInference.compose()
     }
 
-    override fun transformBlock(block: FirBlock, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         dataFlowAnalyzer.enterBlock(block)
         @Suppress("NAME_SHADOWING")
         val block = block.transformChildren(transformer, data) as FirBlock
@@ -183,14 +180,14 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformThisReceiverExpression(
         thisReceiverExpression: FirThisReceiverExpression,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         return transformQualifiedAccessExpression(thisReceiverExpression, data)
     }
 
-    override fun transformOperatorCall(operatorCall: FirOperatorCall, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformOperatorCall(operatorCall: FirOperatorCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         val result = if (operatorCall.operation in FirOperation.BOOLEANS) {
-            (operatorCall.transformChildren(transformer, noExpectedType) as FirOperatorCall).also {
+            (operatorCall.transformChildren(transformer, ResolutionMode.ContextIndependent) as FirOperatorCall).also {
                 it.resultType = builtinTypes.booleanType
             }
         } else {
@@ -200,7 +197,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         if (operatorCall.operation in FirOperation.ASSIGNMENTS) {
             require(operatorCall.operation != FirOperation.ASSIGN)
             @Suppress("NAME_SHADOWING")
-            val operatorCall = operatorCall.transformArguments(this, noExpectedType)
+            val operatorCall = operatorCall.transformArguments(this, ResolutionMode.ContextIndependent)
             val (leftArgument, rightArgument) = operatorCall.arguments
 
             fun createFunctionCall(name: Name) = FirFunctionCallImpl(operatorCall.source).apply {
@@ -217,12 +214,12 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
             // x.plusAssign(y)
             val assignmentOperatorName = FirOperationNameConventions.ASSIGNMENTS.getValue(operatorCall.operation)
             val assignOperatorCall = createFunctionCall(assignmentOperatorName)
-            val resolvedAssignCall = assignOperatorCall.transformSingle(this, noExpectedType)
+            val resolvedAssignCall = assignOperatorCall.transformSingle(this, ResolutionMode.ContextIndependent)
             val assignCallReference = resolvedAssignCall.toResolvedCallableReference()
             // x + y
             val simpleOperatorName = FirOperationNameConventions.ASSIGNMENTS_TO_SIMPLE_OPERATOR.getValue(operatorCall.operation)
             val simpleOperatorCall = createFunctionCall(simpleOperatorName)
-            val resolvedOperatorCall = simpleOperatorCall.transformSingle(this, noExpectedType)
+            val resolvedOperatorCall = simpleOperatorCall.transformSingle(this, ResolutionMode.ContextIndependent)
             val operatorCallReference = resolvedOperatorCall.toResolvedCallableReference()
 
             val property = (leftArgument.toResolvedCallableSymbol() as? FirPropertySymbol)?.fir
@@ -234,7 +231,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                             lValue = (leftArgument as? FirQualifiedAccess)?.calleeReference
                                 ?: FirErrorNamedReferenceImpl(null, FirUnresolvedReferenceError())
                         }
-                    assignment.transform(transformer, noExpectedType)
+                    assignment.transform(transformer, ResolutionMode.ContextIndependent)
                 }
                 else -> FirErrorExpressionImpl(
                     operatorCall.source,
@@ -247,7 +244,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         return result.compose()
     }
 
-    override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         val symbolProvider = session.firSymbolProvider
         val resolved = transformExpression(typeOperatorCall, data).single
         when ((resolved as FirTypeOperatorCall).operation) {
@@ -274,34 +271,34 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformBinaryLogicExpression(
         binaryLogicExpression: FirBinaryLogicExpression,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         val booleanType = builtinTypes.booleanType
         return when (binaryLogicExpression.kind) {
             LogicOperationKind.AND ->
                 binaryLogicExpression.also(dataFlowAnalyzer::enterBinaryAnd)
-                    .transformLeftOperand(this, booleanType).also(dataFlowAnalyzer::exitLeftBinaryAndArgument)
+                    .transformLeftOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitLeftBinaryAndArgument)
-                    .transformRightOperand(this, booleanType).also(dataFlowAnalyzer::exitBinaryAnd)
+                    .transformRightOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitBinaryAnd)
 
             LogicOperationKind.OR ->
                 binaryLogicExpression.also(dataFlowAnalyzer::enterBinaryOr)
-                    .transformLeftOperand(this, booleanType).also(dataFlowAnalyzer::exitLeftBinaryOrArgument)
+                    .transformLeftOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitLeftBinaryOrArgument)
-                    .transformRightOperand(this, booleanType).also(dataFlowAnalyzer::exitBinaryOr)
+                    .transformRightOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitBinaryOr)
-        }.transformOtherChildren(transformer, booleanType).also {
+        }.transformOtherChildren(transformer, ResolutionMode.WithExpectedType(booleanType)).also {
             it.resultType = booleanType
         }.compose()
     }
 
     override fun transformVariableAssignment(
         variableAssignment: FirVariableAssignment,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         // val resolvedAssignment = transformCallee(variableAssignment)
         val resolvedAssignment = callResolver.resolveVariableAccessAndSelectCandidate(variableAssignment, file)
         val result = if (resolvedAssignment is FirVariableAssignment) {
-            val completeAssignment = callCompleter.completeCall(resolvedAssignment, noExpectedType)
+            val completeAssignment = callCompleter.completeCall(resolvedAssignment, noExpectedType) // TODO: check
             val expectedType = components.typeFromCallee(completeAssignment)
-            completeAssignment.transformRValue(transformer, expectedType)
+            completeAssignment.transformRValue(transformer, withExpectedType(expectedType))
         } else {
             // This can happen in erroneous code only
             resolvedAssignment
@@ -313,14 +310,14 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformCallableReferenceAccess(
         callableReferenceAccess: FirCallableReferenceAccess,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         if (callableReferenceAccess.calleeReference is FirResolvedNamedReference) {
             return callableReferenceAccess.compose()
         }
 
         val transformedLHS =
-            callableReferenceAccess.explicitReceiver?.transformSingle(this, noExpectedType)
+            callableReferenceAccess.explicitReceiver?.transformSingle(this, ResolutionMode.ContextIndependent)
 
         val callableReferenceAccessWithTransformedLHS =
             if (transformedLHS != null)
@@ -328,10 +325,10 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
             else
                 callableReferenceAccess
 
-        if (data != null) {
+        if (data !is ResolutionMode.ContextDependent) {
             val resolvedReference =
                 components.syntheticCallGenerator.resolveCallableReferenceWithSyntheticOuterCall(
-                    callableReferenceAccess, data as? FirTypeRef
+                    callableReferenceAccess, data.expectedType
                 ) ?: callableReferenceAccess
 
             return resolvedReference.compose()
@@ -340,7 +337,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         return callableReferenceAccessWithTransformedLHS.compose()
     }
 
-    override fun transformGetClassCall(getClassCall: FirGetClassCall, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         val transformedGetClassCall = transformExpression(getClassCall, data).single as FirGetClassCall
         val kClassSymbol = ClassId.fromString("kotlin/reflect/KClass")(session.firSymbolProvider)
 
@@ -371,7 +368,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformWrappedDelegateExpression(
         wrappedDelegateExpression: FirWrappedDelegateExpression,
-        data: Any?
+        data: ResolutionMode
     ): CompositeTransformResult<FirStatement> {
         transformExpression(wrappedDelegateExpression, data)
         with(wrappedDelegateExpression) {
@@ -383,8 +380,8 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         }
     }
 
-    override fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
-        val expectedType = data as FirTypeRef?
+        val expectedType = data.expectedType
 
         val kind = constExpression.kind
         if (expectedType == null || expectedType is FirImplicitTypeRef ||
@@ -422,7 +419,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         }
     }
 
-    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): CompositeTransformResult<FirStatement> {
+    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         dataFlowAnalyzer.enterAnnotationCall(annotationCall)
         return (annotationCall.transformChildren(transformer, data) as FirAnnotationCall).also {
             dataFlowAnalyzer.exitAnnotationCall(it)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve
 
 import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 
 abstract class FirPartialBodyResolveTransformer(
@@ -20,7 +21,7 @@ abstract class FirPartialBodyResolveTransformer(
             transformer.implicitTypeOnly = value
         }
 
-    override fun <E : FirElement> transformElement(element: E, data: Any?): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): CompositeTransformResult<E> {
         return element.transform(transformer, data)
     }
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.FirProvider
+import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.runResolve
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
@@ -143,7 +144,7 @@ private fun FirDeclaration.runResolve(
             designation.iterator(), state.getSession(psi as KtElement),
             implicitTypeOnly = toPhase == FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE
         )
-        file.transform<FirFile, Nothing?>(transformer, null)
+        file.transform<FirFile, ResolutionMode>(transformer, ResolutionMode.ContextDependent)
     }
 }