FIR: preliminary refactoring of delegate resolve

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

@@ -27,7 +27,7 @@ abstract class AbstractManyCandidatesInferenceSession(
         get() = partiallyResolvedCalls.lastOrNull()
             ?.second
             ?.system
-            ?.currentStorage()
+            ?.asReadOnlyStorage()
             ?: ConstraintStorage.Empty
 
     override fun <T> addCompletedCall(call: T, candidate: Candidate) where T : FirResolvable, T : FirStatement {
@@ -48,4 +48,10 @@ abstract class AbstractManyCandidatesInferenceSession(
 
     protected val FirResolvable.candidate: Candidate
         get() = candidate()!!
+
+    override fun clear() {
+        errorCalls.clear()
+        partiallyResolvedCalls.clear()
+        completedCalls.clear()
+    }
 }

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

@@ -421,6 +421,7 @@ class ConstraintSystemCompleter(private val components: BodyResolveComponents) {
 fun FirStatement.processAllContainingCallCandidates(processBlocks: Boolean, processor: (Candidate) -> Unit) {
     when (this) {
         is FirFunctionCall -> {
+            explicitReceiver?.processAllContainingCallCandidates(processBlocks, processor)
             processCandidateIfApplicable(processor, processBlocks)
             this.arguments.forEach { it.processAllContainingCallCandidates(processBlocks, processor) }
         }
@@ -446,10 +447,12 @@ fun FirStatement.processAllContainingCallCandidates(processBlocks: Boolean, proc
         }
 
         is FirQualifiedAccessExpression -> {
+            explicitReceiver?.processAllContainingCallCandidates(processBlocks, processor)
             processCandidateIfApplicable(processor, processBlocks)
         }
 
         is FirVariableAssignment -> {
+            explicitReceiver?.processAllContainingCallCandidates(processBlocks, processor)
             processCandidateIfApplicable(processor, processBlocks)
             rValue.processAllContainingCallCandidates(processBlocks, processor)
         }

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.resolve.calls.Candidate
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
+import org.jetbrains.kotlin.fir.resolve.calls.InferenceError
 import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -82,7 +83,7 @@ class FirDelegatedPropertyInferenceSession(
 
         for ((_, candidate) in partiallyResolvedCalls) {
             for (error in commonSystem.errors) {
-                candidate.system.addError(error)
+                candidate.addDiagnostic(InferenceError(error))
             }
         }
 

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

@@ -35,6 +35,8 @@ abstract class FirInferenceSession {
     abstract fun <T> writeOnlyStubs(call: T): Boolean where T : FirResolvable, T : FirStatement
     abstract fun <T> callCompleted(call: T): Boolean where T : FirResolvable, T : FirStatement
     abstract fun <T> shouldCompleteResolvedSubAtomsOf(call: T): Boolean where T : FirResolvable, T : FirStatement
+
+    abstract fun clear()
 }
 
 abstract class FirStubInferenceSession : FirInferenceSession() {
@@ -56,4 +58,7 @@ abstract class FirStubInferenceSession : FirInferenceSession() {
     override fun <T> writeOnlyStubs(call: T): Boolean where T : FirResolvable, T : FirStatement = false
     override fun <T> callCompleted(call: T): Boolean where T : FirResolvable, T : FirStatement = false
     override fun <T> shouldCompleteResolvedSubAtomsOf(call: T): Boolean where T : FirResolvable, T : FirStatement = true
+
+    override fun clear() {
+    }
 }

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

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.fir.expressions.builder.buildUnitExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirLazyBlock
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
+import org.jetbrains.kotlin.fir.resolve.calls.FirErrorReferenceWithCandidate
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
 import org.jetbrains.kotlin.fir.resolve.constructFunctionalTypeRef
 import org.jetbrains.kotlin.fir.resolve.dfa.FirControlFlowGraphReferenceImpl
@@ -140,7 +141,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
             var backingFieldIsAlreadyResolved = false
             context.withProperty(property) {
                 context.forPropertyInitializer {
-                    property.transformDelegate(transformer, ResolutionMode.ContextDependentDelegate)
                     if (!initializerIsAlreadyResolved) {
                         property.transformChildrenWithoutComponents(returnTypeRef)
                         property.replaceBodyResolveState(FirPropertyBodyResolveState.INITIALIZER_RESOLVED)
@@ -265,6 +265,13 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
 
     private fun transformPropertyAccessorsWithDelegate(property: FirProperty, delegateExpression: FirExpression) {
         context.forPropertyDelegateAccessors(property, delegateExpression, resolutionContext, callCompleter) {
+            if (property.isLocal) {
+                property.transformDelegate(transformer, ResolutionMode.ContextDependentDelegate)
+            } else {
+                context.forPropertyInitializer {
+                    property.transformDelegate(transformer, ResolutionMode.ContextDependentDelegate)
+                }
+            }
             property.transformAccessors()
             val completedCalls = completeCandidates()
             val finalSubstitutor = createFinalSubstitutor()
@@ -290,6 +297,8 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
             val delegateProvider = wrappedDelegateExpression.delegateProvider.transformSingle(transformer, data)
             when (val calleeReference = (delegateProvider as FirResolvable).calleeReference) {
                 is FirResolvedNamedReference -> return delegateProvider
+                is FirErrorReferenceWithCandidate -> {
+                }
                 is FirNamedReferenceWithCandidate -> {
                     val candidate = calleeReference.candidate
                     if (!candidate.system.hasContradiction) {
@@ -298,7 +307,9 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
                 }
             }
 
+            context.inferenceSession.clear()
             (delegateProvider as? FirFunctionCall)?.let { dataFlowAnalyzer.dropSubgraphFromCall(it) }
+
             return wrappedDelegateExpression.expression
                 .transformSingle(transformer, data)
                 .approximateIfIsIntegerConst()
@@ -309,7 +320,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
 
     private fun transformLocalVariable(variable: FirProperty): FirProperty {
         assert(variable.isLocal)
-        variable.transformDelegate(transformer, ResolutionMode.ContextDependentDelegate)
         val delegate = variable.delegate
 
         val hadExplicitType = variable.returnTypeRef !is FirImplicitTypeRef
@@ -341,7 +351,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
         val data = withExpectedType(returnTypeRef)
         return transformReturnTypeRef(transformer, data)
             .transformInitializer(transformer, data)
-            .transformDelegate(transformer, data)
             .transformTypeParameters(transformer, data)
             .transformOtherChildren(transformer, data)
     }