From d4038f35b6fcf1d71d7aa9ce4356f8197a2cbf31 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Sep 2020 12:26:37 +0300 Subject: [PATCH] [FIR] Make BodyResolveComponents an abstract class --- .../jetbrains/kotlin/fir/FirCallResolver.kt | 37 +++++++-------- .../kotlin/fir/FirQualifiedNameResolver.kt | 5 +- .../fir/resolve/BodyResolveComponents.kt | 46 +++++++++---------- .../fir/resolve/inference/FirCallCompleter.kt | 26 +++++------ .../transformers/FirSyntheticCallGenerator.kt | 15 +++--- .../FirAbstractBodyResolveTransformer.kt | 2 +- .../FirExpressionsResolveTransformer.kt | 2 +- 7 files changed, 68 insertions(+), 65 deletions(-) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt index 7b50192401a..cbd42589fa0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt @@ -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() != null ) { - val approximatedQualifiedAccess = qualifiedAccess.transformExplicitReceiver(integerLiteralTypeApproximator, null) + val approximatedQualifiedAccess = qualifiedAccess.transformExplicitReceiver(components.integerLiteralTypeApproximator, null) if (approximatedQualifiedAccess.explicitReceiver?.typeRef?.coneTypeSafe() == 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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirQualifiedNameResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirQualifiedNameResolver.kt index 74d96de7f46..3b73b85dd67 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirQualifiedNameResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirQualifiedNameResolver.kt @@ -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() 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) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt index 9fc7f902d42..6beb9d63559 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt @@ -34,29 +34,29 @@ interface SessionHolder { val scopeSession: ScopeSession } -interface BodyResolveComponents : SessionHolder { - val returnTypeCalculator: ReturnTypeCalculator - val implicitReceiverStack: ImplicitReceiverStack - val containingDeclarations: List - val fileImportsScope: List - val towerDataElements: List - 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 + abstract val fileImportsScope: List + abstract val towerDataElements: List + 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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt index 9b93cd8ab2c..c765cb3ab5b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt @@ -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 completeCall(call: T, expectedTypeRef: FirTypeRef?): CompletionResult 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) } - 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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt index 4b2dc50d48d..1d17a4c42db 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt @@ -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 { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt index 8f7a14bd936..c51bb5fe29c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt @@ -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 get() = context.fileImportsScope override val towerDataElements: List get() = context.towerDataContext.towerDataElements override val localScopes: FirLocalScopes get() = context.towerDataContext.localScopes diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index 89f73b4f55c..ed22adb1232 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -927,6 +927,6 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform // ------------------------------------------------------------------------------------------------ internal fun storeTypeFromCallee(access: T) where T : FirQualifiedAccess, T : FirExpression { - access.resultType = callCompleter.typeFromCallee(access) + access.resultType = components.typeFromCallee(access) } }