[FIR] Make InferenceComponents session component

2020-09-08 16:04:54 +03:00
parent 41b395b0aa
commit 29addd2a2b
15 changed files with 52 additions and 59 deletions
@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticNamesProvider
 import org.jetbrains.kotlin.fir.resolve.calls.jvm.JvmCallConflictResolverFactory
+import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirQualifierResolverImpl
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirTypeResolverImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.plugin.GeneratedClassIndex
@@ -32,6 +33,7 @@ fun FirSession.registerCommonComponents() {
    register(FirRegisteredPluginAnnotations::class, FirRegisteredPluginAnnotations.create(this))
    register(FirPredicateBasedProvider::class, FirPredicateBasedProvider.create(this))
    register(GeneratedClassIndex::class, GeneratedClassIndex.create())
+    register(InferenceComponents::class, InferenceComponents(this))
 }

 // -------------------------- Resolve components --------------------------
@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.fir.resolve.calls.tower.FirTowerResolver
 import org.jetbrains.kotlin.fir.resolve.calls.tower.TowerResolveManager
 import org.jetbrains.kotlin.fir.resolve.diagnostics.*
 import org.jetbrains.kotlin.fir.resolve.inference.ResolvedCallableReferenceAtom
+import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.transformers.StoreNameReference
 import org.jetbrains.kotlin.fir.resolve.transformers.StoreReceiver
@@ -55,9 +56,8 @@ class FirCallResolver(
        components, resolutionStageRunner,
    )

-    private val conflictResolver =
-        inferenceComponents.session.callConflictResolverFactory
-            .create(TypeSpecificityComparator.NONE, inferenceComponents)
+    private val conflictResolver: ConeCallConflictResolver =
+        session.callConflictResolverFactory.create(TypeSpecificityComparator.NONE, session.inferenceComponents)

    @PrivateForInline
    var needTransformArguments: Boolean = true
@@ -8,14 +8,14 @@ package org.jetbrains.kotlin.fir
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.processOverriddenFunctions
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.types.ConeInferenceContext
-import org.jetbrains.kotlin.fir.types.ConeTypeCheckerContext

 val FirSession.typeContext: ConeInferenceContext
-    get() = ConeTypeCheckerContext(isErrorTypeEqualsToAnything = false, isStubTypeEqualsToAnything = false, this)
+    get() = inferenceComponents.ctx

 /**
 * Returns the list of functions that overridden by given
@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.fir.resolve.calls.ImplicitReceiverValue
 import org.jetbrains.kotlin.fir.resolve.calls.ResolutionStageRunner
 import org.jetbrains.kotlin.fir.resolve.dfa.FirDataFlowAnalyzer
 import org.jetbrains.kotlin.fir.resolve.inference.FirCallCompleter
-import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.FirSyntheticCallGenerator
 import org.jetbrains.kotlin.fir.resolve.transformers.IntegerLiteralTypeApproximationTransformer
@@ -48,7 +47,6 @@ interface BodyResolveComponents : SessionHolder {
    val symbolProvider: FirSymbolProvider
    val file: FirFile
    val container: FirDeclaration
-    val inferenceComponents: InferenceComponents
    val resolutionStageRunner: ResolutionStageRunner
    val samResolver: FirSamResolver
    val callResolver: FirCallResolver
@@ -20,10 +20,10 @@ import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
 import org.jetbrains.kotlin.fir.resolve.calls.ImplicitDispatchReceiverValue
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
+import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
 import org.jetbrains.kotlin.fir.resolve.providers.*
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
 import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolved
-import org.jetbrains.kotlin.fir.scopes.impl.FirDeclaredMemberScopeProvider
 import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
 import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -241,7 +241,7 @@ fun BodyResolveComponents.transformQualifiedAccessUsingSmartcastInfo(qualifiedAc
    val allTypes = typesFromSmartCast.also {
        it += qualifiedAccessExpression.resultType.coneType
    }
-    val intersectedType = ConeTypeIntersector.intersectTypes(inferenceComponents.ctx, allTypes)
+    val intersectedType = ConeTypeIntersector.intersectTypes(session.inferenceComponents.ctx, allTypes)
    // TODO: add check that intersectedType is not equal to original type
    val intersectedTypeRef = buildResolvedTypeRef {
        source = qualifiedAccessExpression.resultType.source?.fakeElement(FirFakeSourceElementKind.SmartCastedTypeRef)
@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
 import org.jetbrains.kotlin.fir.renderWithType
 import org.jetbrains.kotlin.fir.resolve.inference.TypeParameterBasedTypeVariable
+import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
 import org.jetbrains.kotlin.fir.resolve.inference.model.ConeDeclaredUpperBoundConstraintPosition
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
@@ -66,7 +67,7 @@ internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() {
                    getTypePreservingFlexibilityWrtTypeVariable(
                        typeArgument.typeRef.coneType,
                        typeParameter,
-                        context.bodyResolveComponents.inferenceComponents.ctx
+                        context.session.inferenceComponents.ctx
                    ),
                    SimpleConstraintSystemConstraintPosition // TODO
                )
@@ -37,7 +37,7 @@ data class ResolutionContext(
    val bodyResolveContext: BodyResolveContext
 ) {
    val inferenceComponents: InferenceComponents
-        get() = bodyResolveComponents.inferenceComponents
+        get() = session.inferenceComponents

    val returnTypeCalculator: ReturnTypeCalculator
        get() = bodyResolveComponents.returnTypeCalculator
@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.*
 import org.jetbrains.kotlin.fir.resolve.dfa.contracts.buildContractFir
 import org.jetbrains.kotlin.fir.resolve.dfa.contracts.createArgumentsMapping
+import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
@@ -76,31 +77,32 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
                private val receiverStack: PersistentImplicitReceiverStack
                    get() = components.implicitReceiverStack as PersistentImplicitReceiverStack

-                override val logicSystem: PersistentLogicSystem = object : PersistentLogicSystem(components.inferenceComponents.ctx) {
-                    override fun processUpdatedReceiverVariable(flow: PersistentFlow, variable: RealVariable) {
-                        val symbol = variable.identifier.symbol
+                override val logicSystem: PersistentLogicSystem =
+                    object : PersistentLogicSystem(components.session.inferenceComponents.ctx) {
+                        override fun processUpdatedReceiverVariable(flow: PersistentFlow, variable: RealVariable) {
+                            val symbol = variable.identifier.symbol

-                        val index = receiverStack.getReceiverIndex(symbol) ?: return
-                        val info = flow.getTypeStatement(variable)
+                            val index = receiverStack.getReceiverIndex(symbol) ?: return
+                            val info = flow.getTypeStatement(variable)

-                        if (info == null) {
-                            receiverStack.replaceReceiverType(index, receiverStack.getOriginalType(index))
-                        } else {
-                            val types = info.exactType.toMutableList().also {
-                                it += receiverStack.getOriginalType(index)
+                            if (info == null) {
+                                receiverStack.replaceReceiverType(index, receiverStack.getOriginalType(index))
+                            } else {
+                                val types = info.exactType.toMutableList().also {
+                                    it += receiverStack.getOriginalType(index)
+                                }
+                                receiverStack.replaceReceiverType(index, context.intersectTypesOrNull(types)!!)
                            }
-                            receiverStack.replaceReceiverType(index, context.intersectTypesOrNull(types)!!)
                        }
-                    }

-                    override fun updateAllReceivers(flow: PersistentFlow) {
-                        receiverStack.forEach {
-                            variableStorage.getRealVariable(it.boundSymbol, it.receiverExpression, flow)?.let { variable ->
-                                processUpdatedReceiverVariable(flow, variable)
+                        override fun updateAllReceivers(flow: PersistentFlow) {
+                            receiverStack.forEach {
+                                variableStorage.getRealVariable(it.boundSymbol, it.receiverExpression, flow)?.let { variable ->
+                                    processUpdatedReceiverVariable(flow, variable)
+                                }
                            }
                        }
                    }
-                }
            }
    }

@@ -30,7 +30,8 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs

 class ConstraintSystemCompleter(private val components: BodyResolveComponents) {
-    val variableFixationFinder = VariableFixationFinder(components.inferenceComponents.trivialConstraintTypeInferenceOracle)
+    val inferenceComponents = components.session.inferenceComponents
+    val variableFixationFinder = VariableFixationFinder(inferenceComponents.trivialConstraintTypeInferenceOracle)

    fun complete(
        c: ConstraintSystemCompletionContext,
@@ -133,7 +134,7 @@ class ConstraintSystemCompleter(private val components: BodyResolveComponents) {
        typeVariableCreator: () -> V,
        newAtomCreator: (V, ConeKotlinType) -> PostponedResolvedAtom
    ): PostponedResolvedAtom {
-        val functionalType = (components.inferenceComponents.resultTypeResolver.findResultType(
+        val functionalType = (inferenceComponents.resultTypeResolver.findResultType(
            c,
            c.notFixedTypeVariables.getValue(variable.typeConstructor),
            TypeVariableDirectionCalculator.ResolveDirection.TO_SUPERTYPE
@@ -208,7 +209,7 @@ class ConstraintSystemCompleter(private val components: BodyResolveComponents) {
        postponedResolveKtPrimitives: List<PostponedResolvedAtom>
    ) {
        val direction = TypeVariableDirectionCalculator(c, postponedResolveKtPrimitives, topLevelType).getDirection(variableWithConstraints)
-        val resultType = components.inferenceComponents.resultTypeResolver.findResultType(c, variableWithConstraints, direction)
+        val resultType = inferenceComponents.resultTypeResolver.findResultType(c, variableWithConstraints, direction)
        val variable = variableWithConstraints.typeVariable
        c.fixVariable(variable, resultType, ConeFixVariableConstraintPosition(variable)) // TODO: obtain atom for diagnostics
    }
@@ -109,7 +109,7 @@ class FirBuilderInferenceSession(
    }

    private fun buildCommonSystem(initialStorage: ConstraintStorage): Pair<NewConstraintSystemImpl, Boolean> {
-        val commonSystem = components.inferenceComponents.createConstraintSystem()
+        val commonSystem = components.session.inferenceComponents.createConstraintSystem()
        val nonFixedToVariablesSubstitutor = createNonFixedTypeToVariableSubstitutor()

        integrateConstraints(commonSystem, initialStorage, nonFixedToVariablesSubstitutor, false)
@@ -136,7 +136,7 @@ class FirBuilderInferenceSession(
    }

    private fun createNonFixedTypeToVariableSubstitutor(): ConeSubstitutor {
-        val ctx = components.inferenceComponents.ctx
+        val ctx = components.session.inferenceComponents.ctx

        val bindings = mutableMapOf<TypeConstructorMarker, ConeKotlinType>()
        for ((variable, nonFixedType) in stubsForPostponedVariables) {
@@ -64,7 +64,7 @@ class FirCallCompleter(
            candidate.system.addSubtypeConstraint(initialType, expectedTypeRef.type, SimpleConstraintSystemConstraintPosition)
        }

-        val completionMode = candidate.computeCompletionMode(inferenceComponents, expectedTypeRef, initialType)
+        val completionMode = candidate.computeCompletionMode(session.inferenceComponents, expectedTypeRef, initialType)

        val analyzer = createPostponedArgumentsAnalyzer(transformer.resolutionContext)
        call.transformSingle(InvocationKindTransformer, null)
@@ -76,11 +76,11 @@ class FirCallCompleter(
                        analyzer.analyze(candidate.system.asPostponedArgumentsAnalyzerContext(), it, candidate)
                    }
                    val finalSubstitutor =
-                        candidate.system.asReadOnlyStorage().buildAbstractResultingSubstitutor(inferenceComponents.ctx) as ConeSubstitutor
+                        candidate.system.asReadOnlyStorage().buildAbstractResultingSubstitutor(session.inferenceComponents.ctx) as ConeSubstitutor
                    val completedCall = call.transformSingle(
                        FirCallCompletionResultsWriterTransformer(
                            session, finalSubstitutor, returnTypeCalculator,
-                            inferenceComponents.approximator,
+                            session.inferenceComponents.approximator,
                            integerOperatorsTypeUpdater,
                            integerLiteralTypeApproximator
                        ),
@@ -119,7 +119,7 @@ class FirCallCompleter(
    ): FirCallCompletionResultsWriterTransformer {
        return FirCallCompletionResultsWriterTransformer(
            session, substitutor, returnTypeCalculator,
-            inferenceComponents.approximator,
+            session.inferenceComponents.approximator,
            integerOperatorsTypeUpdater,
            integerLiteralTypeApproximator,
            mode
@@ -131,7 +131,7 @@ class FirCallCompleter(
        return PostponedArgumentsAnalyzer(
            context,
            lambdaAnalyzer,
-            inferenceComponents,
+            session.inferenceComponents,
            transformer.components.callResolver
        )
    }
@@ -210,7 +210,7 @@ class FirCallCompleter(
    }

    private fun ConeKotlinType.approximateLambdaInputType(): ConeKotlinType =
-        inferenceComponents.approximator.approximateToSuperType(
+        session.inferenceComponents.approximator.approximateToSuperType(
            this, TypeApproximatorConfiguration.FinalApproximationAfterResolutionAndInference
        ) as ConeKotlinType? ?: this
 }
@@ -64,7 +64,7 @@ class FirDelegatedPropertyInferenceSession(
    fun completeCandidates(): List<FirResolvable> {
        @Suppress("UNCHECKED_CAST")
        val resolvedCalls = partiallyResolvedCalls.map { it.first }
-        val commonSystem = components.inferenceComponents.createConstraintSystem().apply {
+        val commonSystem = components.session.inferenceComponents.createConstraintSystem().apply {
            addOtherSystem(currentConstraintSystem)
        }
        prepareForCompletion(commonSystem, resolvedCalls)
@@ -100,7 +100,7 @@ class FirDelegatedPropertyInferenceSession(

    fun createFinalSubstitutor(): ConeSubstitutor {
        return resultingConstraintSystem.asReadOnlyStorage()
-            .buildAbstractResultingSubstitutor(components.inferenceComponents.ctx) as ConeSubstitutor
+            .buildAbstractResultingSubstitutor(components.session.inferenceComponents.ctx) as ConeSubstitutor
    }

    private fun Candidate.addConstraintsForGetValueMethod(commonSystem: ConstraintSystemBuilder) {
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.inference

 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSessionComponent
 import org.jetbrains.kotlin.fir.types.ConeInferenceContext
 import org.jetbrains.kotlin.fir.types.ConeTypeCheckerContext
 import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintIncorporator
@@ -15,7 +16,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.components.TrivialConstraint
 import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintSystemImpl
 import org.jetbrains.kotlin.types.AbstractTypeApproximator

-class InferenceComponents(val session: FirSession) {
+class InferenceComponents(val session: FirSession) : FirSessionComponent {
    val ctx: ConeInferenceContext = ConeTypeCheckerContext(isErrorTypeEqualsToAnything = false, isStubTypeEqualsToAnything = false, session)

    val approximator: AbstractTypeApproximator = object : AbstractTypeApproximator(ctx) {}
@@ -36,3 +37,5 @@ class InferenceComponents(val session: FirSession) {
        }
    }
 }
+
+val FirSession.inferenceComponents: InferenceComponents by FirSession.sessionComponentAccessor()
@@ -6,18 +6,13 @@
 package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve

 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildVarargArgumentsExpression
 import org.jetbrains.kotlin.fir.renderWithType
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
-import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
 import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.arrayElementType
@@ -37,15 +32,6 @@ internal inline var FirExpression.resultType: FirTypeRef
        replaceTypeRef(type)
    }

-internal fun inferenceComponents(
-    session: FirSession,
-    returnTypeCalculator: ReturnTypeCalculator,
-    scopeSession: ScopeSession
-): InferenceComponents {
-    val inferenceContext = session.typeContext
-    return InferenceComponents(session)
-}
-
 internal fun remapArgumentsWithVararg(
    varargParameter: FirValueParameter,
    varargArrayType: ConeKotlinType,
@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.fir.resolve.calls.ResolutionStageRunner
 import org.jetbrains.kotlin.fir.resolve.dfa.FirDataFlowAnalyzer
 import org.jetbrains.kotlin.fir.resolve.inference.FirCallCompleter
 import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
+import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.*
 import org.jetbrains.kotlin.fir.scopes.FirScope
@@ -74,7 +75,7 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb
    protected inline val symbolProvider: FirSymbolProvider get() = components.symbolProvider

    protected inline val implicitReceiverStack: ImplicitReceiverStack get() = components.implicitReceiverStack
-    protected inline val inferenceComponents: InferenceComponents get() = components.inferenceComponents
+    protected inline val inferenceComponents: InferenceComponents get() = session.inferenceComponents
    protected inline val resolutionStageRunner: ResolutionStageRunner get() = components.resolutionStageRunner
    protected inline val samResolver: FirSamResolver get() = components.samResolver
    protected inline val typeResolverTransformer: FirSpecificTypeResolverTransformer get() = components.typeResolverTransformer
@@ -115,7 +116,6 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb
        override val noExpectedType: FirTypeRef = buildImplicitTypeRef()
        override val symbolProvider: FirSymbolProvider = session.firSymbolProvider

-        override val inferenceComponents: InferenceComponents = inferenceComponents(session, returnTypeCalculator, scopeSession)
        override val resolutionStageRunner: ResolutionStageRunner = ResolutionStageRunner()
        override val samResolver: FirSamResolver = FirSamResolverImpl(session, scopeSession)
        private val qualifiedResolver: FirQualifiedNameResolver = FirQualifiedNameResolver(this)
@@ -131,7 +131,7 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb
            FirDataFlowAnalyzer.createFirDataFlowAnalyzer(this, context.dataFlowAnalyzerContext)
        override val syntheticCallGenerator: FirSyntheticCallGenerator = FirSyntheticCallGenerator(this)
        override val integerLiteralTypeApproximator: IntegerLiteralTypeApproximationTransformer =
-            IntegerLiteralTypeApproximationTransformer(symbolProvider, inferenceComponents.ctx, inferenceComponents.session)
+            IntegerLiteralTypeApproximationTransformer(symbolProvider, session.inferenceComponents.ctx, session)
        override val doubleColonExpressionResolver: FirDoubleColonExpressionResolver =
            FirDoubleColonExpressionResolver(session, integerLiteralTypeApproximator)
        override val integerOperatorsTypeUpdater: IntegerOperatorsTypeUpdater = IntegerOperatorsTypeUpdater(integerLiteralTypeApproximator)