From 1003b81c93c2a9d73780bfa7d31cde0d3cba5b1d Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 26 Feb 2020 11:10:14 +0300 Subject: [PATCH] [FIR] Introduce inference session --- .../kotlin/fir/resolve/SessionHolder.kt | 2 + .../fir/resolve/calls/CandidateFactory.kt | 4 +- .../fir/resolve/inference/FirCallCompleter.kt | 88 ++++++++++++------- .../resolve/inference/FirInferenceSession.kt | 54 ++++++++++++ .../resolve/inference/InferenceComponents.kt | 15 ++++ .../inference/PostponedArgumentsAnalyzer.kt | 52 ++++++----- .../transformers/FirSyntheticCallGenerator.kt | 4 +- .../FirAbstractBodyResolveTransformer.kt | 5 +- .../FirExpressionsResolveTransformer.kt | 1 - 9 files changed, 160 insertions(+), 65 deletions(-) create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirInferenceSession.kt diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SessionHolder.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SessionHolder.kt index 69c3ac8f53c..4b71f805077 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SessionHolder.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SessionHolder.kt @@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirResolvePhase 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.transformers.* import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol @@ -34,6 +35,7 @@ interface BodyResolveComponents : SessionHolder { val scopeSession: ScopeSession val samResolver: FirSamResolver val callResolver: FirCallResolver + val callCompleter: FirCallCompleter val doubleColonExpressionResolver: FirDoubleColonExpressionResolver val syntheticCallGenerator: FirSyntheticCallGenerator val dataFlowAnalyzer: FirDataFlowAnalyzer<*> diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt index db9281e5519..2c66cae9c66 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt @@ -6,12 +6,9 @@ package org.jetbrains.kotlin.fir.resolve.calls import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionWithSmartcast import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents -import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype import org.jetbrains.kotlin.fir.returnExpressions import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol -import org.jetbrains.kotlin.fir.types.coneTypeUnsafe import org.jetbrains.kotlin.resolve.calls.components.PostponedArgumentsAnalyzer import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind @@ -28,6 +25,7 @@ class CandidateFactory private constructor( callInfo.arguments.forEach { system.addSubsystemFromExpression(it) } + system.addOtherSystem(bodyResolveComponents.inferenceComponents.inferenceSession.currentConstraintSystem) return system.asReadOnlyStorage() } } 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 3a2e9eaa78c..be203fda73f 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 @@ -13,10 +13,10 @@ 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.calls.candidate import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor -import org.jetbrains.kotlin.fir.resolve.transformers.* -import org.jetbrains.kotlin.fir.resolve.transformers.MapArguments +import org.jetbrains.kotlin.fir.resolve.transformers.FirCallCompletionResultsWriterTransformer +import org.jetbrains.kotlin.fir.resolve.transformers.InvocationKindTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType @@ -30,9 +30,8 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.calls.components.InferenceSession import org.jetbrains.kotlin.resolve.calls.inference.buildAbstractResultingSubstitutor -import org.jetbrains.kotlin.resolve.calls.inference.components.KotlinConstraintSystemCompleter +import org.jetbrains.kotlin.resolve.calls.inference.components.KotlinConstraintSystemCompleter.ConstraintSystemCompletionMode import org.jetbrains.kotlin.resolve.calls.inference.model.SimpleConstraintSystemConstraintPosition import org.jetbrains.kotlin.types.TypeApproximatorConfiguration import org.jetbrains.kotlin.types.model.StubTypeMarker @@ -42,7 +41,9 @@ class FirCallCompleter( private val transformer: FirBodyResolveTransformer, components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents ) : BodyResolveComponents by components { - private val completer = ConstraintSystemCompleter(components.inferenceComponents) + val completer = ConstraintSystemCompleter(components.inferenceComponents) + private val inferenceSession + get() = inferenceComponents.inferenceSession fun completeCall(call: T, expectedTypeRef: FirTypeRef?): T where T : FirResolvable, T : FirStatement { @@ -51,7 +52,7 @@ class FirCallCompleter( if (call is FirExpression) { call.resultType = typeRef } - return if (call is FirFunctionCall) { + val errorCall = if (call is FirFunctionCall) { call.transformArguments( transformer, ResolutionMode.WithExpectedType(typeRef.resolvedTypeFromPrototype(session.builtinTypes.nullableAnyType.type)) @@ -59,7 +60,10 @@ class FirCallCompleter( } else { call } + inferenceSession.addErrorCall(errorCall) + return errorCall } + val candidate = call.candidate() ?: return call val initialSubstitutor = candidate.substitutor @@ -75,31 +79,50 @@ class FirCallCompleter( val completionMode = candidate.computeCompletionMode(inferenceComponents, expectedTypeRef, initialType) - val analyzer = - PostponedArgumentsAnalyzer( - LambdaAnalyzerImpl(), inferenceComponents, candidate, - transformer.components.callResolver - ) - + val analyzer = createPostponedArgumentsAnalyzer() call.transformSingle(InvocationKindTransformer, null) - completer.complete(candidate.system.asConstraintSystemCompleterContext(), completionMode, listOf(call), initialType) { - analyzer.analyze(candidate.system.asPostponedArgumentsAnalyzerContext(), it) - } - if (completionMode == KotlinConstraintSystemCompleter.ConstraintSystemCompletionMode.FULL) { - val finalSubstitutor = - candidate.system.asReadOnlyStorage().buildAbstractResultingSubstitutor(inferenceComponents.ctx) as ConeSubstitutor - return call.transformSingle( - FirCallCompletionResultsWriterTransformer( - session, finalSubstitutor, returnTypeCalculator, - inferenceComponents.approximator, - integerOperatorsTypeUpdater, - integerLiteralTypeApproximator - ), - null - ) + return when (completionMode) { + ConstraintSystemCompletionMode.FULL -> { + if (inferenceSession.shouldRunCompletion(candidate)) { + completer.complete(candidate.system.asConstraintSystemCompleterContext(), completionMode, listOf(call), initialType) { + analyzer.analyze(candidate.system.asPostponedArgumentsAnalyzerContext(), it, candidate) + } + val finalSubstitutor = + candidate.system.asReadOnlyStorage().buildAbstractResultingSubstitutor(inferenceComponents.ctx) as ConeSubstitutor + val completedCall = call.transformSingle( + FirCallCompletionResultsWriterTransformer( + session, finalSubstitutor, returnTypeCalculator, + inferenceComponents.approximator, + integerOperatorsTypeUpdater, + integerLiteralTypeApproximator + ), + null + ) + inferenceSession.addCompetedCall(completedCall) + completedCall + } else { + inferenceSession.addPartiallyResolvedCall(call) + call + } + } + + ConstraintSystemCompletionMode.PARTIAL -> { + completer.complete(candidate.system.asConstraintSystemCompleterContext(), completionMode, listOf(call), initialType) { + analyzer.analyze(candidate.system.asPostponedArgumentsAnalyzerContext(), it, candidate) + } + val approximatedCall = call.transformSingle(integerOperatorsTypeUpdater, null) + inferenceSession.addPartiallyResolvedCall(approximatedCall) + approximatedCall + } } - return call.transformSingle(integerOperatorsTypeUpdater, null) + } + + fun createPostponedArgumentsAnalyzer(): PostponedArgumentsAnalyzer { + return PostponedArgumentsAnalyzer( + LambdaAnalyzerImpl(), inferenceComponents, + transformer.components.callResolver + ) } private inner class LambdaAnalyzerImpl : LambdaAnalyzer { @@ -111,8 +134,7 @@ class FirCallCompleter( expectedReturnType: ConeKotlinType?, rawReturnType: ConeKotlinType, stubsForPostponedVariables: Map - ): Pair, InferenceSession> { - + ): ReturnArgumentsAnalysisResult { val needItParam = lambdaArgument.valueParameters.isEmpty() && parameters.size == 1 val itParam = when { @@ -153,7 +175,9 @@ class FirCallCompleter( lambdaArgument.transformSingle(transformer, ResolutionMode.LambdaResolution(expectedReturnTypeRef)) val returnArguments = dataFlowAnalyzer.returnExpressionsOfAnonymousFunction(lambdaArgument) - return returnArguments to InferenceSession.default + + // TODO: add detecting of coroutine inference session + return ReturnArgumentsAnalysisResult(returnArguments, null) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirInferenceSession.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirInferenceSession.kt new file mode 100644 index 00000000000..0af043c503a --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirInferenceSession.kt @@ -0,0 +1,54 @@ +/* + * Copyright 2010-2020 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.inference + +import org.jetbrains.kotlin.fir.expressions.FirResolvable +import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.resolve.calls.Candidate +import org.jetbrains.kotlin.fir.types.ConeKotlinType +import org.jetbrains.kotlin.fir.types.ConeTypeVariableTypeConstructor +import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage + +abstract class FirInferenceSession { + companion object { + val DEFAULT: FirInferenceSession = object : FirInferenceSession() { + override fun shouldRunCompletion(candidate: Candidate): Boolean = true + + override val currentConstraintSystem: ConstraintStorage + get() = ConstraintStorage.Empty + + override fun addPartiallyResolvedCall(call: T) where T : FirResolvable, T : FirStatement {} + override fun addErrorCall(call: T) where T : FirResolvable, T : FirStatement {} + override fun addCompetedCall(call: T) where T : FirResolvable, T : FirStatement {} + + override fun inferPostponedVariables( + lambda: ResolvedLambdaAtom, + initialStorage: ConstraintStorage + ): Map = emptyMap() + + override fun callCompleted(call: T): Boolean where T : FirResolvable, T : FirStatement = false + override fun shouldCompleteResolvedSubAtomsOf(call: T): Boolean where T : FirResolvable, T : FirStatement = true + } + } + + abstract fun shouldRunCompletion(candidate: Candidate): Boolean + abstract val currentConstraintSystem: ConstraintStorage + + abstract fun addPartiallyResolvedCall(call: T) where T : FirResolvable, T : FirStatement + abstract fun addErrorCall(call: T) where T : FirResolvable, T : FirStatement + abstract fun addCompetedCall(call: T) where T : FirResolvable, T : FirStatement + + abstract fun inferPostponedVariables( + lambda: ResolvedLambdaAtom, + initialStorage: ConstraintStorage, + // TODO: diagnostic holder + ): Map + +// TODO: do we need this? +// abstract fun writeOnlyStubs(): Boolean + abstract fun callCompleted(call: T): Boolean where T : FirResolvable, T : FirStatement + abstract fun shouldCompleteResolvedSubAtomsOf(call: T): Boolean where T : FirResolvable, T : FirStatement +} \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceComponents.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceComponents.kt index e416f3b7840..5bb61f4b627 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceComponents.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceComponents.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.fir.resolve.inference import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.PrivateForInline import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator import org.jetbrains.kotlin.fir.types.ConeClassErrorType @@ -37,6 +38,20 @@ class InferenceComponents( private val injector = ConstraintInjector(incorporator, approximator, KotlinTypeRefiner.Default) val resultTypeResolver = ResultTypeResolver(approximator, trivialConstraintTypeInferenceOracle) + @set:PrivateForInline + var inferenceSession: FirInferenceSession = FirInferenceSession.DEFAULT + + @UseExperimental(PrivateForInline::class) + inline fun withInferenceSession(inferenceSession: FirInferenceSession, block: () -> R): R { + val oldSession = this.inferenceSession + this.inferenceSession = inferenceSession + return try { + block() + } finally { + this.inferenceSession = oldSession + } + } + fun createConstraintSystem(): NewConstraintSystemImpl { return NewConstraintSystemImpl(injector, ctx) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt index fb0aed95b72..4eff8a6ee12 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt @@ -14,9 +14,10 @@ import org.jetbrains.kotlin.fir.resolve.calls.* import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedReferenceError import org.jetbrains.kotlin.fir.resolve.transformers.StoreNameReference import org.jetbrains.kotlin.fir.types.ConeKotlinType +import org.jetbrains.kotlin.fir.types.ConeTypeVariable import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef -import org.jetbrains.kotlin.resolve.calls.components.InferenceSession import org.jetbrains.kotlin.resolve.calls.components.PostponedArgumentsAnalyzer +import org.jetbrains.kotlin.resolve.calls.inference.model.CoroutinePosition import org.jetbrains.kotlin.resolve.calls.inference.model.SimpleConstraintSystemConstraintPosition import org.jetbrains.kotlin.resolve.calls.model.PostponedResolvedAtomMarker import org.jetbrains.kotlin.types.model.StubTypeMarker @@ -24,6 +25,11 @@ import org.jetbrains.kotlin.types.model.TypeVariableMarker import org.jetbrains.kotlin.types.model.freshTypeConstructor import org.jetbrains.kotlin.types.model.safeSubstitute +data class ReturnArgumentsAnalysisResult( + val returnArguments: List, + val inferenceSession: FirInferenceSession? +) + interface LambdaAnalyzer { fun analyzeAndGetLambdaReturnArguments( lambdaArgument: FirAnonymousFunction, @@ -33,33 +39,33 @@ interface LambdaAnalyzer { expectedReturnType: ConeKotlinType?, // null means, that return type is not proper i.e. it depends on some type variables rawReturnType: ConeKotlinType, stubsForPostponedVariables: Map - ): Pair, InferenceSession> + ): ReturnArgumentsAnalysisResult } class PostponedArgumentsAnalyzer( private val lambdaAnalyzer: LambdaAnalyzer, private val components: InferenceComponents, - private val candidate: Candidate, private val callResolver: FirCallResolver ) { fun analyze( c: PostponedArgumentsAnalyzer.Context, // resolutionCallbacks: KotlinResolutionCallbacks, - argument: PostponedResolvedAtomMarker + argument: PostponedResolvedAtomMarker, + candidate: Candidate //diagnosticsHolder: KotlinDiagnosticsHolder ) { when (argument) { is ResolvedLambdaAtom -> - analyzeLambda(c, argument/*, diagnosticsHolder*/) + analyzeLambda(c, argument, candidate/*, diagnosticsHolder*/) // is LambdaWithTypeVariableAsExpectedTypeAtom -> // analyzeLambda( // c, resolutionCallbacks, argument.transformToResolvedLambda(c.getBuilder()), diagnosticsHolder // ) - is ResolvedCallableReferenceAtom -> processCallableReference(argument) + is ResolvedCallableReferenceAtom -> processCallableReference(argument, candidate) // // is ResolvedCollectionLiteralAtom -> TODO("Not supported") @@ -67,7 +73,7 @@ class PostponedArgumentsAnalyzer( } } - private fun processCallableReference(atom: ResolvedCallableReferenceAtom) { + private fun processCallableReference(atom: ResolvedCallableReferenceAtom, candidate: Candidate) { if (atom.postponed) { callResolver.resolveCallableReference(candidate.csBuilder, atom) } @@ -98,7 +104,8 @@ class PostponedArgumentsAnalyzer( private fun analyzeLambda( c: PostponedArgumentsAnalyzer.Context, - lambda: ResolvedLambdaAtom//, + lambda: ResolvedLambdaAtom, + candidate: Candidate //diagnosticHolder: KotlinDiagnosticsHolder ) { val unitType = components.session.builtinTypes.unitType.type//Unit(components.session.firSymbolProvider).constructType(emptyArray(), false) @@ -136,7 +143,6 @@ class PostponedArgumentsAnalyzer( val subResolvedKtPrimitives = returnArguments.map { if (it !is FirExpression) return@map - var atom: PostponedResolvedAtomMarker? = null candidate.resolveArgumentExpression( c.getBuilder(), it, @@ -153,7 +159,6 @@ class PostponedArgumentsAnalyzer( } if (returnArguments.isEmpty()) { -// val unitType = val lambdaReturnType = lambda.returnType.let(::substitute) c.getBuilder().addSubtypeConstraint( lambdaReturnType, @@ -169,21 +174,20 @@ class PostponedArgumentsAnalyzer( lambda.analyzed = true lambda.returnStatements = returnArguments - //lambda.setAnalyzedResults(returnArguments, subResolvedKtPrimitives) -// if (inferenceSession != null) { -// val storageSnapshot = c.getBuilder().currentStorage() -// -// val postponedVariables = inferenceSession.inferPostponedVariables(lambda, storageSnapshot) -// -// for ((constructor, resultType) in postponedVariables) { -// val variableWithConstraints = storageSnapshot.notFixedTypeVariables[constructor] ?: continue -// val variable = variableWithConstraints.typeVariable -// -// c.getBuilder().unmarkPostponedVariable(variable) -// c.getBuilder().addEqualityConstraint(variable.defaultType(c), resultType, CoroutinePosition()) -// } -// } + if (inferenceSession != null) { + val storageSnapshot = c.getBuilder().currentStorage() + + val postponedVariables = inferenceSession.inferPostponedVariables(lambda, storageSnapshot) + + for ((constructor, resultType) in postponedVariables) { + val variableWithConstraints = storageSnapshot.notFixedTypeVariables[constructor] ?: continue + val variable = variableWithConstraints.typeVariable as ConeTypeVariable + + c.getBuilder().unmarkPostponedVariable(variable) + c.getBuilder().addEqualityConstraint(variable.defaultType, resultType, CoroutinePosition()) + } + } } } 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 16c1efccb29..de2908d1ac9 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.FirUnresolvedNameError -import org.jetbrains.kotlin.fir.resolve.inference.FirCallCompleter import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer import org.jetbrains.kotlin.fir.symbols.CallableId import org.jetbrains.kotlin.fir.symbols.SyntheticCallableId @@ -41,8 +40,7 @@ import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind import org.jetbrains.kotlin.types.Variance class FirSyntheticCallGenerator( - private val components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents, - private val callCompleter: FirCallCompleter + private val components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents ) : BodyResolveComponents by components { private val whenSelectFunction: FirSimpleFunction = generateSyntheticSelectFunction(SyntheticCallableId.WHEN) private val trySelectFunction: FirSimpleFunction = generateSyntheticSelectFunction(SyntheticCallableId.TRY) 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 7369903e53d..f5529150de4 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 @@ -73,6 +73,7 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb protected inline val resolutionStageRunner: ResolutionStageRunner get() = components.resolutionStageRunner protected inline val samResolver: FirSamResolver get() = components.samResolver protected inline val typeResolverTransformer: FirSpecificTypeResolverTransformer get() = components.typeResolverTransformer + protected inline val callResolver: FirCallResolver get() = components.callResolver protected inline val callCompleter: FirCallCompleter get() = components.callCompleter protected inline val dataFlowAnalyzer: FirDataFlowAnalyzer<*> get() = components.dataFlowAnalyzer protected inline val scopeSession: ScopeSession get() = components.scopeSession @@ -121,9 +122,9 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb val typeResolverTransformer = FirSpecificTypeResolverTransformer( FirTypeResolveScopeForBodyResolve(topLevelScopes, implicitReceiverStack, localScopes), session ) - val callCompleter: FirCallCompleter = FirCallCompleter(transformer, this) + override val callCompleter: FirCallCompleter = FirCallCompleter(transformer, this) override val dataFlowAnalyzer: FirDataFlowAnalyzer<*> = FirDataFlowAnalyzer.createFirDataFlowAnalyzer(this) - override val syntheticCallGenerator: FirSyntheticCallGenerator = FirSyntheticCallGenerator(this, callCompleter) + override val syntheticCallGenerator: FirSyntheticCallGenerator = FirSyntheticCallGenerator(this) override val integerLiteralTypeApproximator: IntegerLiteralTypeApproximationTransformer = IntegerLiteralTypeApproximationTransformer(symbolProvider, inferenceComponents.ctx) override val integerOperatorsTypeUpdater: IntegerOperatorsTypeUpdater = IntegerOperatorsTypeUpdater(integerLiteralTypeApproximator) 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 e66edc305c7..b9ceec56d8f 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 @@ -43,7 +43,6 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : FirPartialBodyResolveTransformer(transformer) { - private val callResolver: FirCallResolver get() = components.callResolver private inline val builtinTypes: BuiltinTypes get() = session.builtinTypes init {