[FIR] Make BodyResolveComponents an abstract class

2020-09-14 12:26:37 +03:00
parent dfd7f33bd3
commit d4038f35b6
7 changed files with 68 additions and 65 deletions
@@ -44,7 +44,8 @@ import org.jetbrains.kotlin.types.Variance
 class FirCallResolver(
    private val components: BodyResolveComponents,
    private val qualifiedResolver: FirQualifiedNameResolver,
-) : BodyResolveComponents by components {
+) {
+    private val session = components.session

    private lateinit var transformer: FirExpressionsResolveTransformer

@@ -53,7 +54,7 @@ class FirCallResolver(
    }

    private val towerResolver = FirTowerResolver(
-        components, resolutionStageRunner,
+        components, components.resolutionStageRunner,
    )

    private val conflictResolver: ConeCallConflictResolver =
@@ -69,7 +70,7 @@ class FirCallResolver(
        val functionCall = if (needTransformArguments) {
            functionCall.transformExplicitReceiver()
                .also {
-                    dataFlowAnalyzer.enterQualifiedAccessExpression()
+                    components.dataFlowAnalyzer.enterQualifiedAccessExpression()
                    functionCall.argumentList.transformArguments(transformer, ResolutionMode.ContextDependent)
                }
        } else {
@@ -102,7 +103,7 @@ class FirCallResolver(
        } else {
            resultExpression
        }
-        val typeRef = typeFromCallee(resultFunctionCall)
+        val typeRef = components.typeFromCallee(resultFunctionCall)
        if (typeRef.type is ConeKotlinErrorType) {
            resultFunctionCall.resultType = typeRef
        }
@@ -142,7 +143,7 @@ class FirCallResolver(
                    qualifiedResolver.isPotentialQualifierPartPosition(),
            typeArguments,
            session,
-            file,
+            components.file,
            transformer.components.containingDeclarations,
        )
        towerResolver.reset()
@@ -159,7 +160,7 @@ class FirCallResolver(
        if ((reducedCandidates.isEmpty() || !result.currentApplicability.isSuccess) &&
            explicitReceiver?.typeRef?.coneTypeSafe<ConeIntegerLiteralType>() != null
        ) {
-            val approximatedQualifiedAccess = qualifiedAccess.transformExplicitReceiver(integerLiteralTypeApproximator, null)
+            val approximatedQualifiedAccess = qualifiedAccess.transformExplicitReceiver(components.integerLiteralTypeApproximator, null)
            if (approximatedQualifiedAccess.explicitReceiver?.typeRef?.coneTypeSafe<ConeIntegerLiteralType>() == null) {
                return collectCandidates(approximatedQualifiedAccess, name)
            }
@@ -216,7 +217,7 @@ class FirCallResolver(

        when {
            referencedSymbol is FirClassLikeSymbol<*> -> {
-                return buildResolvedQualifierForClass(referencedSymbol, nameReference.source, qualifiedAccess.typeArguments, diagnostic)
+                return components.buildResolvedQualifierForClass(referencedSymbol, nameReference.source, qualifiedAccess.typeArguments, diagnostic)
            }
            referencedSymbol is FirTypeParameterSymbol && referencedSymbol.fir.isReified -> {
                return buildResolvedReifiedParameterReference {
@@ -251,7 +252,7 @@ class FirCallResolver(
            expectedType, constraintSystemBuilder,
        )
        // No reset here!
-        val localCollector = CandidateCollector(this, resolutionStageRunner)
+        val localCollector = CandidateCollector(components, components.resolutionStageRunner)
        val result = towerResolver.runResolver(
            info,
            transformer.resolutionContext,
@@ -309,8 +310,8 @@ class FirCallResolver(
            isPotentialQualifierPart = false,
            typeArguments = typeArguments,
            session,
-            file,
-            containingDeclarations,
+            components.file,
+            components.containingDeclarations,
        )
        towerResolver.reset()

@@ -320,7 +321,7 @@ class FirCallResolver(
            transformer.resolutionContext
        )

-        return callResolver.selectDelegatingConstructorCall(delegatedConstructorCall, name, result, callInfo)
+        return components.callResolver.selectDelegatingConstructorCall(delegatedConstructorCall, name, result, callInfo)
    }

    private fun ConeTypeProjection.toFirTypeProjection(): FirTypeProjection = when (this) {
@@ -356,8 +357,8 @@ class FirCallResolver(
            isPotentialQualifierPart = false,
            typeArguments = emptyList(),
            session,
-            file,
-            containingDeclarations
+            components.file,
+            components.containingDeclarations
        )

        val annotationClassSymbol = annotationCall.getCorrespondingClassSymbolOrNull(session)
@@ -390,7 +391,7 @@ class FirCallResolver(
        callInfo: CallInfo
    ): ResolutionResult? {
        var constructorSymbol: FirConstructorSymbol? = null
-        annotationClassSymbol.fir.unsubstitutedScope(session, scopeSession).processDeclaredConstructors {
+        annotationClassSymbol.fir.unsubstitutedScope(session, components.scopeSession).processDeclaredConstructors {
            if (it.fir.isPrimary && constructorSymbol == null) {
                constructorSymbol = it
            }
@@ -400,7 +401,7 @@ class FirCallResolver(
            constructorSymbol!!,
            ExplicitReceiverKind.NO_EXPLICIT_RECEIVER
        )
-        val applicability = resolutionStageRunner.processCandidate(candidate, transformer.resolutionContext)
+        val applicability = components.resolutionStageRunner.processCandidate(candidate, transformer.resolutionContext)
        return ResolutionResult(callInfo, applicability, listOf(candidate))
    }

@@ -458,7 +459,7 @@ class FirCallResolver(
            isPotentialQualifierPart = false,
            emptyList(),
            session,
-            file,
+            components.file,
            transformer.components.containingDeclarations,
            candidateForCommonInvokeReceiver = null,
            // Additional things for callable reference resolve
@@ -542,7 +543,7 @@ class FirCallResolver(
        name: Name
    ): FirErrorReferenceWithCandidate {
        val candidate = CandidateFactory(transformer.resolutionContext, callInfo).createErrorCandidate(diagnostic)
-        resolutionStageRunner.processCandidate(candidate, transformer.resolutionContext, stopOnFirstError = false)
+        components.resolutionStageRunner.processCandidate(candidate, transformer.resolutionContext, stopOnFirstError = false)
        return FirErrorReferenceWithCandidate(source, name, candidate, diagnostic)
    }

@@ -552,7 +553,7 @@ class FirCallResolver(
        diagnostic: ConeDiagnostic
    ): FirErrorReferenceWithCandidate {
        if (!candidate.fullyAnalyzed) {
-            resolutionStageRunner.processCandidate(candidate, transformer.resolutionContext, stopOnFirstError = false)
+            components.resolutionStageRunner.processCandidate(candidate, transformer.resolutionContext, stopOnFirstError = false)
        }
        return FirErrorReferenceWithCandidate(source, candidate.callInfo.name, candidate, diagnostic)
    }
@@ -19,7 +19,8 @@ import org.jetbrains.kotlin.fir.resolve.typeForQualifier
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name

-class FirQualifiedNameResolver(components: BodyResolveComponents) : BodyResolveComponents by components {
+class FirQualifiedNameResolver(private val components: BodyResolveComponents) {
+    private val session = components.session
    private var qualifierStack = mutableListOf<Name>()
    private var qualifierPartsToDrop = 0

@@ -80,7 +81,7 @@ class FirQualifiedNameResolver(components: BodyResolveComponents) : BodyResolveC
                relativeClassFqName = resolved.relativeClassFqName
                symbol = resolved.classSymbol
            }.apply {
-                resultType = typeForQualifier(this)
+                resultType = components.typeForQualifier(this)
            }
        }

@@ -34,29 +34,29 @@ interface SessionHolder {
    val scopeSession: ScopeSession
 }

-interface BodyResolveComponents : SessionHolder {
-    val returnTypeCalculator: ReturnTypeCalculator
-    val implicitReceiverStack: ImplicitReceiverStack
-    val containingDeclarations: List<FirDeclaration>
-    val fileImportsScope: List<FirScope>
-    val towerDataElements: List<FirTowerDataElement>
-    val towerDataContext: FirTowerDataContext
-    val localScopes: FirLocalScopes
-    val towerDataContextForAnonymousFunctions: TowerDataContextForAnonymousFunctions
-    val noExpectedType: FirTypeRef
-    val symbolProvider: FirSymbolProvider
-    val file: FirFile
-    val container: FirDeclaration
-    val resolutionStageRunner: ResolutionStageRunner
-    val samResolver: FirSamResolver
-    val callResolver: FirCallResolver
-    val callCompleter: FirCallCompleter
-    val doubleColonExpressionResolver: FirDoubleColonExpressionResolver
-    val syntheticCallGenerator: FirSyntheticCallGenerator
-    val dataFlowAnalyzer: FirDataFlowAnalyzer<*>
-    val integerLiteralTypeApproximator: IntegerLiteralTypeApproximationTransformer
-    val integerOperatorsTypeUpdater: IntegerOperatorsTypeUpdater
-    val outerClassManager: FirOuterClassManager
+abstract class BodyResolveComponents : SessionHolder {
+    abstract val returnTypeCalculator: ReturnTypeCalculator
+    abstract val implicitReceiverStack: ImplicitReceiverStack
+    abstract val containingDeclarations: List<FirDeclaration>
+    abstract val fileImportsScope: List<FirScope>
+    abstract val towerDataElements: List<FirTowerDataElement>
+    abstract val towerDataContext: FirTowerDataContext
+    abstract val localScopes: FirLocalScopes
+    abstract val towerDataContextForAnonymousFunctions: TowerDataContextForAnonymousFunctions
+    abstract val noExpectedType: FirTypeRef
+    abstract val symbolProvider: FirSymbolProvider
+    abstract val file: FirFile
+    abstract val container: FirDeclaration
+    abstract val resolutionStageRunner: ResolutionStageRunner
+    abstract val samResolver: FirSamResolver
+    abstract val callResolver: FirCallResolver
+    abstract val callCompleter: FirCallCompleter
+    abstract val doubleColonExpressionResolver: FirDoubleColonExpressionResolver
+    abstract val syntheticCallGenerator: FirSyntheticCallGenerator
+    abstract val dataFlowAnalyzer: FirDataFlowAnalyzer<*>
+    abstract val integerLiteralTypeApproximator: IntegerLiteralTypeApproximationTransformer
+    abstract val integerOperatorsTypeUpdater: IntegerOperatorsTypeUpdater
+    abstract val outerClassManager: FirOuterClassManager
 }

 typealias FirLocalScopes = PersistentList<FirLocalScope>
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 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.FirNamedReferenceWithCandidate
 import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext
@@ -39,7 +38,8 @@ import org.jetbrains.kotlin.utils.addToStdlib.runIf
 class FirCallCompleter(
    private val transformer: FirBodyResolveTransformer,
    private val components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents
-) : BodyResolveComponents by components {
+) {
+    private val session = components.session
    val completer = ConstraintSystemCompleter(components)
    private val inferenceSession
        get() = transformer.context.inferenceSession
@@ -48,7 +48,7 @@ class FirCallCompleter(

    fun <T> completeCall(call: T, expectedTypeRef: FirTypeRef?): CompletionResult<T>
            where T : FirResolvable, T : FirStatement {
-        val typeRef = typeFromCallee(call)
+        val typeRef = components.typeFromCallee(call)

        val reference = call.calleeReference as? FirNamedReferenceWithCandidate ?: return CompletionResult(call, true)
        val candidate = reference.candidate
@@ -79,10 +79,10 @@ class FirCallCompleter(
                        candidate.system.asReadOnlyStorage().buildAbstractResultingSubstitutor(session.inferenceComponents.ctx) as ConeSubstitutor
                    val completedCall = call.transformSingle(
                        FirCallCompletionResultsWriterTransformer(
-                            session, finalSubstitutor, returnTypeCalculator,
+                            session, finalSubstitutor, components.returnTypeCalculator,
                            session.inferenceComponents.approximator,
-                            integerOperatorsTypeUpdater,
-                            integerLiteralTypeApproximator
+                            components.integerOperatorsTypeUpdater,
+                            components.integerLiteralTypeApproximator
                        ),
                        null
                    )
@@ -104,7 +104,7 @@ class FirCallCompleter(
                ) {
                    analyzer.analyze(candidate.system.asPostponedArgumentsAnalyzerContext(), it, candidate)
                }
-                val approximatedCall = call.transformSingle(integerOperatorsTypeUpdater, null)
+                val approximatedCall = call.transformSingle(components.integerOperatorsTypeUpdater, null)
                inferenceSession.addPartiallyResolvedCall(approximatedCall)
                CompletionResult(approximatedCall, false)
            }
@@ -118,10 +118,10 @@ class FirCallCompleter(
        mode: FirCallCompletionResultsWriterTransformer.Mode = FirCallCompletionResultsWriterTransformer.Mode.Normal
    ): FirCallCompletionResultsWriterTransformer {
        return FirCallCompletionResultsWriterTransformer(
-            session, substitutor, returnTypeCalculator,
+            session, substitutor, components.returnTypeCalculator,
            session.inferenceComponents.approximator,
-            integerOperatorsTypeUpdater,
-            integerLiteralTypeApproximator,
+            components.integerOperatorsTypeUpdater,
+            components.integerLiteralTypeApproximator,
            mode
        )
    }
@@ -182,14 +182,14 @@ class FirCallCompleter(
            }

            lambdaArgument.replaceValueParameters(lambdaArgument.valueParameters + listOfNotNull(itParam))
-            lambdaArgument.replaceReturnTypeRef(expectedReturnTypeRef ?: noExpectedType)
+            lambdaArgument.replaceReturnTypeRef(expectedReturnTypeRef ?: components.noExpectedType)

            val builderInferenceSession = runIf(stubsForPostponedVariables.isNotEmpty()) {
                @Suppress("UNCHECKED_CAST")
                FirBuilderInferenceSession(transformer.resolutionContext, stubsForPostponedVariables as Map<ConeTypeVariable, ConeStubType>)
            }

-            val localContext = towerDataContextForAnonymousFunctions.get(lambdaArgument.symbol) ?: error(
+            val localContext = components.towerDataContextForAnonymousFunctions.get(lambdaArgument.symbol) ?: error(
                ""
            )
            transformer.context.withTowerDataContext(localContext) {
@@ -203,7 +203,7 @@ class FirCallCompleter(
            }
            transformer.context.dropContextForAnonymousFunction(lambdaArgument)

-            val returnArguments = dataFlowAnalyzer.returnExpressionsOfAnonymousFunction(lambdaArgument)
+            val returnArguments = components.dataFlowAnalyzer.returnExpressionsOfAnonymousFunction(lambdaArgument)

            return ReturnArgumentsAnalysisResult(returnArguments, builderInferenceSession)
        }
@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.fir.references.impl.FirStubReference
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.calls.*
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
 import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.SyntheticCallableId
@@ -43,8 +42,10 @@ import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
 import org.jetbrains.kotlin.types.Variance

 class FirSyntheticCallGenerator(
-    private val components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents
-) : BodyResolveComponents by components {
+    private val components: BodyResolveComponents
+) {
+    private val session = components.session
+
    private val whenSelectFunction: FirSimpleFunction = generateSyntheticSelectFunction(SyntheticCallableId.WHEN)
    private val trySelectFunction: FirSimpleFunction = generateSyntheticSelectFunction(SyntheticCallableId.TRY)
    private val idFunction: FirSimpleFunction = generateSyntheticSelectFunction(SyntheticCallableId.ID)
@@ -150,7 +151,7 @@ class FirSyntheticCallGenerator(
            this.argumentList = argumentList
        }

-        val argument = callCompleter.completeCall(fakeCallElement, expectedTypeRef).result.argument
+        val argument = components.callCompleter.completeCall(fakeCallElement, expectedTypeRef).result.argument
        return ((argument as? FirVarargArgumentsExpression)?.arguments?.get(0) ?: argument) as FirCallableReferenceAccess?
    }

@@ -163,7 +164,7 @@ class FirSyntheticCallGenerator(
    ): FirNamedReferenceWithCandidate? {
        val callInfo = generateCallInfo(name, argumentList, callKind)
        val candidate = generateCandidate(callInfo, function, context)
-        val applicability = resolutionStageRunner.processCandidate(candidate, context)
+        val applicability = components.resolutionStageRunner.processCandidate(candidate, context)
        if (applicability <= CandidateApplicability.INAPPLICABLE) {
            return null
        }
@@ -185,8 +186,8 @@ class FirSyntheticCallGenerator(
        isPotentialQualifierPart = false,
        typeArguments = emptyList(),
        session = session,
-        containingFile = file,
-        containingDeclarations = containingDeclarations
+        containingFile = components.file,
+        containingDeclarations = components.containingDeclarations
    )

    private fun generateSyntheticSelectTypeParameter(): Pair<FirTypeParameter, FirResolvedTypeRef> {
@@ -99,7 +99,7 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb
        override val scopeSession: ScopeSession,
        val transformer: FirBodyResolveTransformer,
        val context: BodyResolveContext
-    ) : BodyResolveComponents {
+    ) : BodyResolveComponents() {
        override val fileImportsScope: List<FirScope> get() = context.fileImportsScope
        override val towerDataElements: List<FirTowerDataElement> get() = context.towerDataContext.towerDataElements
        override val localScopes: FirLocalScopes get() = context.towerDataContext.localScopes
@@ -927,6 +927,6 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
    // ------------------------------------------------------------------------------------------------

    internal fun <T> storeTypeFromCallee(access: T) where T : FirQualifiedAccess, T : FirExpression {
-        access.resultType = callCompleter.typeFromCallee(access)
+        access.resultType = components.typeFromCallee(access)
    }
 }