azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIR] Introduce ResolutionMode as data for body resolve instead of Any?

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2019-11-05 15:13:42 +03:00
parent 7f58162abc
commit c58ca27b2e
13 changed files with 186 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt
+3 -3
View File
@@ -66,8 +66,8 @@ class FirCallResolver(
fun resolveCallAndSelectCandidate(functionCall: FirFunctionCall, expectedTypeRef: FirTypeRef?, file: FirFile): FirFunctionCall {
qualifiedResolver.reset()
@Suppress("NAME_SHADOWING")
val functionCall = functionCall.transformExplicitReceiver(transformer, noExpectedType)
.transformArguments(transformer, null)
val functionCall = functionCall.transformExplicitReceiver(transformer, ResolutionMode.ContextIndependent)
.transformArguments(transformer, ResolutionMode.ContextDependent)
val name = functionCall.calleeReference.name
@@ -161,7 +161,7 @@ class FirCallResolver(
qualifiedResolver.initProcessingQualifiedAccess(qualifiedAccess, callee)
@Suppress("NAME_SHADOWING")
val qualifiedAccess = qualifiedAccess.transformExplicitReceiver(transformer, noExpectedType)
val qualifiedAccess = qualifiedAccess.transformExplicitReceiver(transformer, ResolutionMode.ContextIndependent)
qualifiedResolver.replacedQualifier(qualifiedAccess)?.let { return it }
val info = CallInfo(
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolutionMode.kt
+19
View File
@@ -0,0 +1,19 @@
/*
* Copyright 2010-2019 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
import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
import org.jetbrains.kotlin.fir.types.FirTypeRef
sealed class ResolutionMode {
object ContextDependent : ResolutionMode()
object ContextIndependent : ResolutionMode()
class WithExpectedType(val expectedTypeRef: FirTypeRef) : ResolutionMode()
class LambdaResolution(val expectedReturnTypeRef: FirResolvedTypeRef?) : ResolutionMode()
}
fun withExpectedType(expectedTypeRef: FirTypeRef?): ResolutionMode =
expectedTypeRef?.let { ResolutionMode.WithExpectedType(it) } ?: ResolutionMode.ContextDependent
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt
+2 -1
View File
@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference
import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
import org.jetbrains.kotlin.fir.resolve.ImplicitReceiverStackImpl
import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.dfa.Condition.*
import org.jetbrains.kotlin.fir.resolve.dfa.cfg.*
import org.jetbrains.kotlin.fir.resolve.dfa.contracts.buildContractFir
@@ -485,7 +486,7 @@ class FirDataFlowAnalyzer(private val components: FirAbstractBodyResolveTransfor
for (conditionalEffect in conditionalEffects) {
val fir = conditionalEffect.buildContractFir(argumentsMapping) ?: continue
val effect = conditionalEffect.effect as? ConeReturnsEffectDeclaration ?: continue
fir.transformSingle(components.transformer, null)
fir.transformSingle(components.transformer, ResolutionMode.ContextDependent)
val argumentVariable = getOrCreateVariable(fir)
val lastNode = graphBuilder.lastNode
when (val value = effect.value) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt
+2 -1
View File
@@ -12,6 +12,7 @@ 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.*
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
import org.jetbrains.kotlin.fir.resolve.transformers.FirCallCompletionResultsWriterTransformer
@@ -141,7 +142,7 @@ class FirCallCompleter(
)
replacements[lambdaArgument] =
newLambdaExpression.transformSingle(transformer, FirDeclarationsResolveTransformer.LambdaResolution(expectedReturnTypeRef))
newLambdaExpression.transformSingle(transformer, ResolutionMode.LambdaResolution(expectedReturnTypeRef))
return (newLambdaExpression.body?.returnExpressions() ?: emptyList()) to InferenceSession.default
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt
+2 -1
View File
@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.firProvider
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformer
@@ -84,7 +85,7 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc
scopeSession
)
file.transform<FirElement, Any?>(transformer, null)
file.transform<FirElement, ResolutionMode>(transformer, ResolutionMode.ContextDependent)
val newReturnTypeRef = declaration.returnTypeRef
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt
+8 -1
View File
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAbstractPhaseTransformer<Any?>(phase) {
abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAbstractPhaseTransformer<ResolutionMode>(phase) {
abstract val components: BodyResolveTransformerComponents
abstract var implicitTypeOnly: Boolean
@@ -78,6 +78,13 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb
protected inline val scopeSession: ScopeSession get() = components.scopeSession
protected inline val file: FirFile get() = components.file
val ResolutionMode.expectedType: FirTypeRef?
get() = when (this) {
is ResolutionMode.WithExpectedType -> expectedTypeRef
is ResolutionMode.ContextIndependent -> noExpectedType
else -> null
}
class BodyResolveTransformerComponents(
override val session: FirSession,
override val scopeSession: ScopeSession,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt
+40 -40
View File
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirTargetElement
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.scopes.addImportingScopes
import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
@@ -34,7 +35,7 @@ open class FirBodyResolveTransformer(
private val declarationsTransformer = FirDeclarationsResolveTransformer(this)
private val controlFlowStatementsTransformer = FirControlFlowStatementsResolveTransformer(this)
override fun transformFile(file: FirFile, data: Any?): CompositeTransformResult<FirFile> {
override fun transformFile(file: FirFile, data: ResolutionMode): CompositeTransformResult<FirFile> {
packageFqName = file.packageFqName
components.file = file
return withScopeCleanup(components.topLevelScopes) {
@@ -44,181 +45,180 @@ open class FirBodyResolveTransformer(
}
}
override fun <E : FirElement> transformElement(element: E, data: Any?): CompositeTransformResult<E> {
override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): CompositeTransformResult<E> {
@Suppress("UNCHECKED_CAST")
return (element.transformChildren(this, data) as E).compose()
}
override fun transformTypeRef(typeRef: FirTypeRef, data: Any?): CompositeTransformResult<FirTypeRef> {
override fun transformTypeRef(typeRef: FirTypeRef, data: ResolutionMode): CompositeTransformResult<FirTypeRef> {
return typeRef.compose()
}
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Any?): CompositeTransformResult<FirTypeRef> {
if (data == null)
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: ResolutionMode): CompositeTransformResult<FirTypeRef> {
if (data !is ResolutionMode.WithExpectedType)
return implicitTypeRef.compose()
require(data is FirTypeRef)
return data.compose()
return data.expectedTypeRef.compose()
}
// ------------------------------------- Expressions -------------------------------------
override fun transformExpression(expression: FirExpression, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformExpression(expression, data)
}
override fun transformQualifiedAccessExpression(
qualifiedAccessExpression: FirQualifiedAccessExpression,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformQualifiedAccessExpression(qualifiedAccessExpression, data)
}
override fun transformFunctionCall(functionCall: FirFunctionCall, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformFunctionCall(functionCall, data)
}
override fun transformCallableReferenceAccess(
callableReferenceAccess: FirCallableReferenceAccess,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformCallableReferenceAccess(callableReferenceAccess, data)
}
override fun transformBlock(block: FirBlock, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformBlock(block, data)
}
override fun transformThisReceiverExpression(
thisReceiverExpression: FirThisReceiverExpression,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformThisReceiverExpression(thisReceiverExpression, data)
}
override fun transformOperatorCall(operatorCall: FirOperatorCall, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformOperatorCall(operatorCall: FirOperatorCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformOperatorCall(operatorCall, data)
}
override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformTypeOperatorCall(typeOperatorCall, data)
}
override fun transformBinaryLogicExpression(
binaryLogicExpression: FirBinaryLogicExpression,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformBinaryLogicExpression(binaryLogicExpression, data)
}
override fun transformVariableAssignment(
variableAssignment: FirVariableAssignment,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformVariableAssignment(variableAssignment, data)
}
override fun transformGetClassCall(getClassCall: FirGetClassCall, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformGetClassCall(getClassCall, data)
}
override fun transformWrappedDelegateExpression(
wrappedDelegateExpression: FirWrappedDelegateExpression,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformWrappedDelegateExpression(wrappedDelegateExpression, data)
}
override fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: Any?): CompositeTransformResult<FirStatement> {
override fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformConstExpression(constExpression, data)
}
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return expressionsTransformer.transformAnnotationCall(annotationCall, data)
}
// ------------------------------------- Declarations -------------------------------------
override fun transformDeclaration(declaration: FirDeclaration, data: Any?): CompositeTransformResult<FirDeclaration> {
override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
return declarationsTransformer.transformDeclaration(declaration, data)
}
override fun transformProperty(property: FirProperty, data: Any?): CompositeTransformResult<FirDeclaration> {
override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
return declarationsTransformer.transformProperty(property, data)
}
override fun transformRegularClass(regularClass: FirRegularClass, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return declarationsTransformer.transformRegularClass(regularClass, data)
}
override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return declarationsTransformer.transformAnonymousObject(anonymousObject, data)
}
override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?): CompositeTransformResult<FirDeclaration> {
override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
return declarationsTransformer.transformSimpleFunction(simpleFunction, data)
}
override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: Any?): CompositeTransformResult<FirStatement> {
override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return declarationsTransformer.transformFunction(function, data)
}
override fun transformConstructor(constructor: FirConstructor, data: Any?): CompositeTransformResult<FirDeclaration> {
override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
return declarationsTransformer.transformConstructor(constructor, data)
}
override fun transformAnonymousInitializer(
anonymousInitializer: FirAnonymousInitializer,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirDeclaration> {
return declarationsTransformer.transformAnonymousInitializer(anonymousInitializer, data)
}
override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return declarationsTransformer.transformAnonymousFunction(anonymousFunction, data)
}
override fun transformValueParameter(valueParameter: FirValueParameter, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return declarationsTransformer.transformValueParameter(valueParameter, data)
}
// ------------------------------------- Control flow statements -------------------------------------
override fun transformWhileLoop(whileLoop: FirWhileLoop, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return controlFlowStatementsTransformer.transformWhileLoop(whileLoop, data)
}
override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return controlFlowStatementsTransformer.transformDoWhileLoop(doWhileLoop, data)
}
override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return controlFlowStatementsTransformer.transformWhenExpression(whenExpression, data)
}
override fun transformWhenBranch(whenBranch: FirWhenBranch, data: Any?): CompositeTransformResult<FirWhenBranch> {
override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): CompositeTransformResult<FirWhenBranch> {
return controlFlowStatementsTransformer.transformWhenBranch(whenBranch, data)
}
override fun transformWhenSubjectExpression(
whenSubjectExpression: FirWhenSubjectExpression,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
return controlFlowStatementsTransformer.transformWhenSubjectExpression(whenSubjectExpression, data)
}
override fun transformTryExpression(tryExpression: FirTryExpression, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return controlFlowStatementsTransformer.transformTryExpression(tryExpression, data)
}
override fun transformCatch(catch: FirCatch, data: Any?): CompositeTransformResult<FirCatch> {
override fun transformCatch(catch: FirCatch, data: ResolutionMode): CompositeTransformResult<FirCatch> {
return controlFlowStatementsTransformer.transformCatch(catch, data)
}
override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: Any?): CompositeTransformResult<FirStatement> {
override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return controlFlowStatementsTransformer.transformJump(jump, data)
}
override fun transformThrowExpression(throwExpression: FirThrowExpression, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformThrowExpression(throwExpression: FirThrowExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return controlFlowStatementsTransformer.transformThrowExpression(throwExpression, data)
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformerAdapters.kt
+5 -4
View File
@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -26,7 +27,7 @@ class FirDesignatedBodyResolveTransformer(
implicitTypeOnly = implicitTypeOnly,
scopeSession = scopeSession
) {
override fun <E : FirElement> transformElement(element: E, data: Any?): CompositeTransformResult<E> {
override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): CompositeTransformResult<E> {
if (designation.hasNext()) {
designation.next().visitNoTransform(this, data)
return element.compose()
@@ -34,7 +35,7 @@ class FirDesignatedBodyResolveTransformer(
return super.transformElement(element, data)
}
override fun transformDeclaration(declaration: FirDeclaration, data: Any?): CompositeTransformResult<FirDeclaration> {
override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
return components.withContainer(declaration) {
declaration.replaceResolvePhase(transformerPhase)
transformElement(declaration, data)
@@ -58,7 +59,7 @@ class FirImplicitTypeBodyResolveTransformerAdapter : FirTransformer<Nothing?>()
implicitTypeOnly = true,
scopeSession = scopeSession
)
return file.transform(transformer, null)
return file.transform(transformer, ResolutionMode.ContextDependent)
}
}
@@ -79,6 +80,6 @@ class FirBodyResolveTransformerAdapter : FirTransformer<Nothing?>() {
implicitTypeOnly = false,
scopeSession = scopeSession
)
return file.transform(transformer, null)
return file.transform(transformer, ResolutionMode.ContextDependent)
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt
+20 -20
View File
@@ -12,12 +12,12 @@ import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyExpressionBlock
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.transformers.FirSyntheticCallGenerator
import org.jetbrains.kotlin.fir.resolve.transformers.FirWhenExhaustivenessTransformer
import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
@@ -32,14 +32,14 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
// ------------------------------- Loops -------------------------------
override fun transformWhileLoop(whileLoop: FirWhileLoop, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return whileLoop.also(dataFlowAnalyzer::enterWhileLoop)
.transformCondition(transformer, data).also(dataFlowAnalyzer::exitWhileLoopCondition)
.transformBlock(transformer, data).also(dataFlowAnalyzer::exitWhileLoop)
.transformOtherChildren(transformer, data).compose()
}
override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return doWhileLoop.also(dataFlowAnalyzer::enterDoWhileLoop)
.transformBlock(transformer, data).also(dataFlowAnalyzer::enterDoWhileLoopCondition)
.transformCondition(transformer, data).also(dataFlowAnalyzer::exitDoWhileLoop)
@@ -48,7 +48,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
// ------------------------------- When expressions -------------------------------
override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
if (whenExpression.calleeReference is FirResolvedNamedReference && whenExpression.resultType !is FirImplicitTypeRef) {
return whenExpression.compose()
}
@@ -58,17 +58,17 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
localScopes += FirLocalScope()
}
@Suppress("NAME_SHADOWING")
var whenExpression = whenExpression.transformSubject(transformer, noExpectedType)
var whenExpression = whenExpression.transformSubject(transformer, ResolutionMode.ContextIndependent)
when {
whenExpression.branches.isEmpty() -> {
}
whenExpression.isOneBranch() -> {
whenExpression = whenExpression.transformBranches(transformer, noExpectedType)
whenExpression = whenExpression.transformBranches(transformer, ResolutionMode.ContextIndependent)
whenExpression.resultType = whenExpression.branches.first().result.resultType
}
else -> {
whenExpression = whenExpression.transformBranches(transformer, null)
whenExpression = whenExpression.transformBranches(transformer, ResolutionMode.ContextDependent)
whenExpression = syntheticCallGenerator.generateCalleeForWhenExpression(whenExpression) ?: run {
whenExpression = whenExpression.transformSingle(whenExhaustivenessTransformer, null)
@@ -77,7 +77,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
return@with whenExpression.compose()
}
val expectedTypeRef = data as FirTypeRef?
val expectedTypeRef = data.expectedType
whenExpression = callCompleter.completeCall(whenExpression, expectedTypeRef)
}
}
@@ -102,7 +102,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
return lastBranch.condition is FirElseIfTrueCondition && lastBranch.result is FirEmptyExpressionBlock
}
override fun transformWhenBranch(whenBranch: FirWhenBranch, data: Any?): CompositeTransformResult<FirWhenBranch> {
override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): CompositeTransformResult<FirWhenBranch> {
return whenBranch.also { dataFlowAnalyzer.enterWhenBranchCondition(whenBranch) }
.transformCondition(transformer, data).also { dataFlowAnalyzer.exitWhenBranchCondition(it) }
.transformResult(transformer, data).also { dataFlowAnalyzer.exitWhenBranchResult(it) }
@@ -111,7 +111,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
override fun transformWhenSubjectExpression(
whenSubjectExpression: FirWhenSubjectExpression,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
val parentWhen = whenSubjectExpression.whenSubject.whenExpression
val subjectType = parentWhen.subject?.resultType ?: parentWhen.subjectVariable?.returnTypeRef
@@ -123,19 +123,19 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
// ------------------------------- Try/catch expressions -------------------------------
override fun transformTryExpression(tryExpression: FirTryExpression, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
if (tryExpression.calleeReference is FirResolvedNamedReference && tryExpression.resultType !is FirImplicitTypeRef) {
return tryExpression.compose()
}
dataFlowAnalyzer.enterTryExpression(tryExpression)
tryExpression.transformTryBlock(transformer, null)
tryExpression.transformTryBlock(transformer, ResolutionMode.ContextDependent)
dataFlowAnalyzer.exitTryMainBlock(tryExpression)
tryExpression.transformCatches(this, null)
tryExpression.transformCatches(this, ResolutionMode.ContextDependent)
@Suppress("NAME_SHADOWING")
var result = syntheticCallGenerator.generateCalleeForTryExpression(tryExpression)?.let {
val expectedTypeRef = data as FirTypeRef?
val expectedTypeRef = data.expectedType
callCompleter.completeCall(it, expectedTypeRef)
} ?: run {
tryExpression.resultType = FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Can't resolve try expression", DiagnosticKind.InferenceError))
@@ -144,7 +144,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
result = if (result.finallyBlock != null) {
result.also(dataFlowAnalyzer::enterFinallyBlock)
.transformFinallyBlock(transformer, noExpectedType)
.transformFinallyBlock(transformer, ResolutionMode.ContextIndependent)
.also(dataFlowAnalyzer::exitFinallyBlock)
} else {
result
@@ -153,24 +153,24 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
return result.compose()
}
override fun transformCatch(catch: FirCatch, data: Any?): CompositeTransformResult<FirCatch> {
override fun transformCatch(catch: FirCatch, data: ResolutionMode): CompositeTransformResult<FirCatch> {
dataFlowAnalyzer.enterCatchClause(catch)
return withScopeCleanup(localScopes) {
localScopes += FirLocalScope()
catch.transformParameter(transformer, noExpectedType)
catch.transformBlock(transformer, null)
catch.transformParameter(transformer, ResolutionMode.ContextIndependent)
catch.transformBlock(transformer, ResolutionMode.ContextDependent)
}.also { dataFlowAnalyzer.exitCatchClause(it) }.compose()
}
// ------------------------------- Jumps -------------------------------
override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: Any?): CompositeTransformResult<FirStatement> {
override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
val result = transformer.transformExpression(jump, data)
dataFlowAnalyzer.exitJump(jump)
return result
}
override fun transformThrowExpression(throwExpression: FirThrowExpression, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformThrowExpression(throwExpression: FirThrowExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return transformer.transformExpression(throwExpression, data).also {
dataFlowAnalyzer.exitThrowExceptionNode(it.single as FirThrowExpression)
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt
+48 -46
View File
@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.calls.ImplicitDispatchReceiverValue
import org.jetbrains.kotlin.fir.resolve.calls.ImplicitExtensionReceiverValue
import org.jetbrains.kotlin.fir.resolve.calls.extractLambdaInfoFromFunctionalType
@@ -20,6 +21,7 @@ import org.jetbrains.kotlin.fir.resolve.constructFunctionalTypeRef
import org.jetbrains.kotlin.fir.resolve.defaultType
import org.jetbrains.kotlin.fir.resolve.transformers.ControlFlowGraphReferenceTransformer
import org.jetbrains.kotlin.fir.resolve.transformers.StoreType
import org.jetbrains.kotlin.fir.resolve.withExpectedType
import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
@@ -36,14 +38,14 @@ import org.jetbrains.kotlin.utils.addIfNotNull
class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) : FirPartialBodyResolveTransformer(transformer) {
private var primaryConstructorParametersScope: FirLocalScope? = null
override fun transformDeclaration(declaration: FirDeclaration, data: Any?): CompositeTransformResult<FirDeclaration> {
override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
return components.withContainer(declaration) {
declaration.replaceResolvePhase(transformerPhase)
transformer.transformElement(declaration, data)
}
}
override fun transformProperty(property: FirProperty, data: Any?): CompositeTransformResult<FirDeclaration> {
override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
if (property.isLocal) return transformLocalVariable(property, data)
val returnTypeRef = property.returnTypeRef
if (returnTypeRef !is FirImplicitTypeRef && implicitTypeOnly) return property.compose()
@@ -75,9 +77,9 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
}
}
private fun transformLocalVariable(variable: FirProperty, data: Any?): CompositeTransformResult<FirDeclaration> {
private fun transformLocalVariable(variable: FirProperty, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
assert(variable.isLocal)
variable.transformOtherChildren(transformer, variable.returnTypeRef)
variable.transformOtherChildren(transformer, withExpectedType(variable.returnTypeRef))
if (variable.initializer != null) {
storeVariableReturnType(variable)
}
@@ -89,8 +91,8 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
}
private fun FirProperty.transformChildrenWithoutAccessors(returnTypeRef: FirTypeRef): FirProperty {
return transformReturnTypeRef(transformer, returnTypeRef).
transformOtherChildren(transformer, returnTypeRef)
val data = withExpectedType(returnTypeRef)
return transformReturnTypeRef(transformer, data).transformOtherChildren(transformer, data)
}
private fun <F : FirVariable<F>> FirVariable<F>.transformAccessors() {
@@ -114,7 +116,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
owner: FirVariable<*>
) {
if (accessor is FirDefaultPropertyAccessor || accessor.body == null) {
transformFunction(accessor, enhancedTypeRef)
transformFunction(accessor, withExpectedType(enhancedTypeRef))
}
val returnTypeRef = accessor.returnTypeRef
if (returnTypeRef is FirImplicitTypeRef && enhancedTypeRef !is FirResolvedTypeRef) {
@@ -135,7 +137,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
} as CompositeTransformResult<FirStatement>
}
override fun transformRegularClass(regularClass: FirRegularClass, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult<FirStatement> {
localScopes.lastOrNull()?.storeDeclaration(regularClass)
val oldConstructorScope = primaryConstructorParametersScope
primaryConstructorParametersScope = null
@@ -153,7 +155,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
return result as CompositeTransformResult<FirStatement>
}
override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: ResolutionMode): CompositeTransformResult<FirStatement> {
val type = anonymousObject.defaultType()
anonymousObject.resultType = FirResolvedTypeRefImpl(anonymousObject.source, type)
val result = withLabelAndReceiverType(null, anonymousObject, type) {
@@ -163,16 +165,16 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
}
private fun transformAnonymousFunctionWithLambdaResolution(
anonymousFunction: FirAnonymousFunction, lambdaResolution: LambdaResolution
anonymousFunction: FirAnonymousFunction, lambdaResolution: ResolutionMode.LambdaResolution
): FirAnonymousFunction {
val receiverTypeRef = anonymousFunction.receiverTypeRef
fun transform(): FirAnonymousFunction {
val expectedReturnType =
lambdaResolution.expectedReturnTypeRef ?: anonymousFunction.returnTypeRef.takeUnless { it is FirImplicitTypeRef }
val result = transformFunction(anonymousFunction, expectedReturnType).single as FirAnonymousFunction
val result = transformFunction(anonymousFunction, withExpectedType(expectedReturnType)).single as FirAnonymousFunction
val body = result.body
return if (result.returnTypeRef is FirImplicitTypeRef && body != null) {
result.transformReturnTypeRef(transformer, body.resultType)
result.transformReturnTypeRef(transformer, withExpectedType(body.resultType))
result
} else {
result
@@ -189,9 +191,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
}
}
data class LambdaResolution(val expectedReturnTypeRef: FirResolvedTypeRef?)
override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?): CompositeTransformResult<FirDeclaration> {
override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
val returnTypeRef = simpleFunction.returnTypeRef
if ((returnTypeRef !is FirImplicitTypeRef) && implicitTypeOnly) {
return simpleFunction.compose()
@@ -219,17 +219,17 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
if (function is FirSimpleFunction) {
localScopes.lastOrNull()?.storeDeclaration(function)
}
val result = transformFunction(function, returnTypeRef).single as FirFunction<*>
val result = transformFunction(function, withExpectedType(returnTypeRef)).single as FirFunction<*>
val body = result.body
return if (result.returnTypeRef is FirImplicitTypeRef && body != null) {
result.transformReturnTypeRef(transformer, body.resultType)
result.transformReturnTypeRef(transformer, withExpectedType(body.resultType))
result
} else {
result
}.compose()
}
override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: Any?): CompositeTransformResult<FirStatement> {
override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return withScopeCleanup(localScopes) {
localScopes += FirLocalScope()
dataFlowAnalyzer.enterFunction(function)
@@ -242,14 +242,14 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
}
}
override fun transformConstructor(constructor: FirConstructor, data: Any?): CompositeTransformResult<FirDeclaration> {
override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
if (implicitTypeOnly) return constructor.compose()
return transformFunction(constructor, data) as CompositeTransformResult<FirDeclaration>
}
override fun transformAnonymousInitializer(
anonymousInitializer: FirAnonymousInitializer,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirDeclaration> {
if (implicitTypeOnly) return anonymousInitializer.compose()
return withScopeCleanup(localScopes) {
@@ -261,25 +261,25 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
}
}
override fun transformValueParameter(valueParameter: FirValueParameter, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult<FirStatement> {
localScopes.lastOrNull()?.storeDeclaration(valueParameter)
if (valueParameter.returnTypeRef is FirImplicitTypeRef) {
valueParameter.replaceResolvePhase(transformerPhase)
return valueParameter.compose() // TODO
}
return (transformDeclaration(valueParameter, valueParameter.returnTypeRef).single as FirStatement).compose()
return (transformDeclaration(valueParameter, withExpectedType(valueParameter.returnTypeRef)).single as FirStatement).compose()
}
override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return when (data) {
null -> {
ResolutionMode.ContextDependent -> {
anonymousFunction.compose()
}
is LambdaResolution -> {
is ResolutionMode.LambdaResolution -> {
transformAnonymousFunctionWithLambdaResolution(anonymousFunction, data).compose()
}
is FirTypeRef -> {
val resolvedLambdaAtom = (data as? FirResolvedTypeRef)?.let {
is ResolutionMode.WithExpectedType -> {
val resolvedLambdaAtom = (data.expectedTypeRef as? FirResolvedTypeRef)?.let {
extractLambdaInfoFromFunctionalType(
it.type, it, anonymousFunction
)
@@ -335,15 +335,15 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
?: af.returnTypeRef
)
af = af.transformValueParameters(ImplicitToErrorTypeTransformer, null)
val bodyExpectedType = returnTypeRefFromResolvedAtom ?: data
af = transformFunction(af, bodyExpectedType).single as FirAnonymousFunction
val bodyExpectedType = returnTypeRefFromResolvedAtom ?: data.expectedTypeRef
af = transformFunction(af, withExpectedType(bodyExpectedType)).single as FirAnonymousFunction
af = af.copy(
returnTypeRef = af.body?.resultType ?: FirErrorTypeRefImpl(af.source, FirSimpleDiagnostic("No result type for lambda", DiagnosticKind.InferenceError))
)
af.replaceTypeRef(af.constructFunctionalTypeRef(session))
af.compose()
}
else -> {
is ResolutionMode.ContextIndependent -> {
transformFunction(anonymousFunction, data).single.compose()
}
}
@@ -380,37 +380,39 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
if (variable.returnTypeRef is FirImplicitTypeRef) {
when {
initializer != null -> {
val expectedType = when (val resultType = initializer.resultType) {
is FirImplicitTypeRef -> FirErrorTypeRefImpl(
null,
FirSimpleDiagnostic("No result type for initializer", DiagnosticKind.InferenceError)
)
else -> resultType
}
variable.transformReturnTypeRef(
transformer,
when (val resultType = initializer.resultType) {
is FirImplicitTypeRef -> FirErrorTypeRefImpl(
null,
FirSimpleDiagnostic("No result type for initializer", DiagnosticKind.InferenceError)
)
else -> resultType
}
withExpectedType(expectedType)
)
}
variable.getter != null && variable.getter !is FirDefaultPropertyAccessor -> {
val expectedType = when (val resultType = variable.getter?.returnTypeRef) {
is FirImplicitTypeRef -> FirErrorTypeRefImpl(
null,
FirSimpleDiagnostic("No result type for getter", DiagnosticKind.InferenceError)
)
else -> resultType
}
variable.transformReturnTypeRef(
transformer,
when (val resultType = variable.getter?.returnTypeRef) {
is FirImplicitTypeRef -> FirErrorTypeRefImpl(
null,
FirSimpleDiagnostic("No result type for getter", DiagnosticKind.InferenceError)
)
else -> resultType
}
withExpectedType(expectedType)
)
}
else -> {
variable.transformReturnTypeRef(
transformer, FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Cannot infer variable type without initializer / getter / delegate", DiagnosticKind.InferenceError))
transformer, withExpectedType(FirErrorTypeRefImpl(null, FirSimpleDiagnostic("Cannot infer variable type without initializer / getter / delegate", DiagnosticKind.InferenceError)))
)
}
}
if (variable.getter?.returnTypeRef is FirImplicitTypeRef) {
variable.getter?.transformReturnTypeRef(transformer, variable.returnTypeRef)
variable.getter?.transformReturnTypeRef(transformer, withExpectedType(variable.returnTypeRef))
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt
+33 -36
View File
@@ -22,16 +22,13 @@ import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference
import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.resolve.*
import org.jetbrains.kotlin.fir.resolve.calls.ConeInferenceContext
import org.jetbrains.kotlin.fir.resolve.calls.candidate
import org.jetbrains.kotlin.fir.resolve.constructType
import org.jetbrains.kotlin.fir.resolve.diagnostics.FirOperatorAmbiguityError
import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedReferenceError
import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
import org.jetbrains.kotlin.fir.resolve.transformers.InvocationKindTransformer
import org.jetbrains.kotlin.fir.resolve.transformers.StoreReceiver
import org.jetbrains.kotlin.fir.resolve.typeFromCallee
import org.jetbrains.kotlin.fir.resolve.withNullability
import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
import org.jetbrains.kotlin.fir.symbols.StandardClassIds
@@ -57,7 +54,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
components.callResolver.initTransformer(this)
}
override fun transformExpression(expression: FirExpression, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) {
val type = FirErrorTypeRefImpl(expression.source, FirSimpleDiagnostic("Type calculating for ${expression::class} is not supported", DiagnosticKind.InferenceError))
expression.resultType = type
@@ -67,7 +64,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
override fun transformQualifiedAccessExpression(
qualifiedAccessExpression: FirQualifiedAccessExpression,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
var result = when (val callee = qualifiedAccessExpression.calleeReference) {
is FirExplicitThisReference -> {
@@ -109,7 +106,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
// NB: here we can get raw expression because of dropped qualifiers (see transform callee),
// so candidate existence must be checked before calling completion
if (transformedCallee is FirQualifiedAccessExpression && transformedCallee.candidate() != null) {
callCompleter.completeCall(transformedCallee, data as? FirTypeRef)
callCompleter.completeCall(transformedCallee, data.expectedType)
} else {
transformedCallee
}
@@ -135,14 +132,14 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
return FirExpressionWithSmartcastImpl(qualifiedAccessExpression, intersectedTypeRef, typesFromSmartCast)
}
override fun transformFunctionCall(functionCall: FirFunctionCall, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
if (functionCall.calleeReference is FirResolvedNamedReference && functionCall.resultType is FirImplicitTypeRef) {
storeTypeFromCallee(functionCall)
}
dataFlowAnalyzer.enterFunctionCall(functionCall)
if (functionCall.calleeReference !is FirSimpleNamedReference) return functionCall.compose()
functionCall.transform<FirFunctionCall, Nothing?>(InvocationKindTransformer, null)
val expectedTypeRef = data as FirTypeRef?
val expectedTypeRef = data.expectedType
val completeInference =
try {
val initialExplicitReceiver = functionCall.explicitReceiver
@@ -161,7 +158,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
return completeInference.compose()
}
override fun transformBlock(block: FirBlock, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult<FirStatement> {
dataFlowAnalyzer.enterBlock(block)
@Suppress("NAME_SHADOWING")
val block = block.transformChildren(transformer, data) as FirBlock
@@ -183,14 +180,14 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
override fun transformThisReceiverExpression(
thisReceiverExpression: FirThisReceiverExpression,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
return transformQualifiedAccessExpression(thisReceiverExpression, data)
}
override fun transformOperatorCall(operatorCall: FirOperatorCall, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformOperatorCall(operatorCall: FirOperatorCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
val result = if (operatorCall.operation in FirOperation.BOOLEANS) {
(operatorCall.transformChildren(transformer, noExpectedType) as FirOperatorCall).also {
(operatorCall.transformChildren(transformer, ResolutionMode.ContextIndependent) as FirOperatorCall).also {
it.resultType = builtinTypes.booleanType
}
} else {
@@ -200,7 +197,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
if (operatorCall.operation in FirOperation.ASSIGNMENTS) {
require(operatorCall.operation != FirOperation.ASSIGN)
@Suppress("NAME_SHADOWING")
val operatorCall = operatorCall.transformArguments(this, noExpectedType)
val operatorCall = operatorCall.transformArguments(this, ResolutionMode.ContextIndependent)
val (leftArgument, rightArgument) = operatorCall.arguments
fun createFunctionCall(name: Name) = FirFunctionCallImpl(operatorCall.source).apply {
@@ -217,12 +214,12 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
// x.plusAssign(y)
val assignmentOperatorName = FirOperationNameConventions.ASSIGNMENTS.getValue(operatorCall.operation)
val assignOperatorCall = createFunctionCall(assignmentOperatorName)
val resolvedAssignCall = assignOperatorCall.transformSingle(this, noExpectedType)
val resolvedAssignCall = assignOperatorCall.transformSingle(this, ResolutionMode.ContextIndependent)
val assignCallReference = resolvedAssignCall.toResolvedCallableReference()
// x + y
val simpleOperatorName = FirOperationNameConventions.ASSIGNMENTS_TO_SIMPLE_OPERATOR.getValue(operatorCall.operation)
val simpleOperatorCall = createFunctionCall(simpleOperatorName)
val resolvedOperatorCall = simpleOperatorCall.transformSingle(this, noExpectedType)
val resolvedOperatorCall = simpleOperatorCall.transformSingle(this, ResolutionMode.ContextIndependent)
val operatorCallReference = resolvedOperatorCall.toResolvedCallableReference()
val property = (leftArgument.toResolvedCallableSymbol() as? FirPropertySymbol)?.fir
@@ -234,7 +231,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
lValue = (leftArgument as? FirQualifiedAccess)?.calleeReference
?: FirErrorNamedReferenceImpl(null, FirUnresolvedReferenceError())
}
assignment.transform(transformer, noExpectedType)
assignment.transform(transformer, ResolutionMode.ContextIndependent)
}
else -> FirErrorExpressionImpl(
operatorCall.source,
@@ -247,7 +244,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
return result.compose()
}
override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
val symbolProvider = session.firSymbolProvider
val resolved = transformExpression(typeOperatorCall, data).single
when ((resolved as FirTypeOperatorCall).operation) {
@@ -274,34 +271,34 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
override fun transformBinaryLogicExpression(
binaryLogicExpression: FirBinaryLogicExpression,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
val booleanType = builtinTypes.booleanType
return when (binaryLogicExpression.kind) {
LogicOperationKind.AND ->
binaryLogicExpression.also(dataFlowAnalyzer::enterBinaryAnd)
.transformLeftOperand(this, booleanType).also(dataFlowAnalyzer::exitLeftBinaryAndArgument)
.transformRightOperand(this, booleanType).also(dataFlowAnalyzer::exitBinaryAnd)
.transformLeftOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitLeftBinaryAndArgument)
.transformRightOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitBinaryAnd)
LogicOperationKind.OR ->
binaryLogicExpression.also(dataFlowAnalyzer::enterBinaryOr)
.transformLeftOperand(this, booleanType).also(dataFlowAnalyzer::exitLeftBinaryOrArgument)
.transformRightOperand(this, booleanType).also(dataFlowAnalyzer::exitBinaryOr)
}.transformOtherChildren(transformer, booleanType).also {
.transformLeftOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitLeftBinaryOrArgument)
.transformRightOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitBinaryOr)
}.transformOtherChildren(transformer, ResolutionMode.WithExpectedType(booleanType)).also {
it.resultType = booleanType
}.compose()
}
override fun transformVariableAssignment(
variableAssignment: FirVariableAssignment,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
// val resolvedAssignment = transformCallee(variableAssignment)
val resolvedAssignment = callResolver.resolveVariableAccessAndSelectCandidate(variableAssignment, file)
val result = if (resolvedAssignment is FirVariableAssignment) {
val completeAssignment = callCompleter.completeCall(resolvedAssignment, noExpectedType)
val completeAssignment = callCompleter.completeCall(resolvedAssignment, noExpectedType) // TODO: check
val expectedType = components.typeFromCallee(completeAssignment)
completeAssignment.transformRValue(transformer, expectedType)
completeAssignment.transformRValue(transformer, withExpectedType(expectedType))
} else {
// This can happen in erroneous code only
resolvedAssignment
@@ -313,14 +310,14 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
override fun transformCallableReferenceAccess(
callableReferenceAccess: FirCallableReferenceAccess,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
if (callableReferenceAccess.calleeReference is FirResolvedNamedReference) {
return callableReferenceAccess.compose()
}
val transformedLHS =
callableReferenceAccess.explicitReceiver?.transformSingle(this, noExpectedType)
callableReferenceAccess.explicitReceiver?.transformSingle(this, ResolutionMode.ContextIndependent)
val callableReferenceAccessWithTransformedLHS =
if (transformedLHS != null)
@@ -328,10 +325,10 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
else
callableReferenceAccess
if (data != null) {
if (data !is ResolutionMode.ContextDependent) {
val resolvedReference =
components.syntheticCallGenerator.resolveCallableReferenceWithSyntheticOuterCall(
callableReferenceAccess, data as? FirTypeRef
callableReferenceAccess, data.expectedType
) ?: callableReferenceAccess
return resolvedReference.compose()
@@ -340,7 +337,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
return callableReferenceAccessWithTransformedLHS.compose()
}
override fun transformGetClassCall(getClassCall: FirGetClassCall, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
val transformedGetClassCall = transformExpression(getClassCall, data).single as FirGetClassCall
val kClassSymbol = ClassId.fromString("kotlin/reflect/KClass")(session.firSymbolProvider)
@@ -371,7 +368,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
override fun transformWrappedDelegateExpression(
wrappedDelegateExpression: FirWrappedDelegateExpression,
data: Any?
data: ResolutionMode
): CompositeTransformResult<FirStatement> {
transformExpression(wrappedDelegateExpression, data)
with(wrappedDelegateExpression) {
@@ -383,8 +380,8 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
}
}
override fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: Any?): CompositeTransformResult<FirStatement> {
val expectedType = data as FirTypeRef?
override fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
val expectedType = data.expectedType
val kind = constExpression.kind
if (expectedType == null || expectedType is FirImplicitTypeRef ||
@@ -422,7 +419,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
}
}
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): CompositeTransformResult<FirStatement> {
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
dataFlowAnalyzer.enterAnnotationCall(annotationCall)
return (annotationCall.transformChildren(transformer, data) as FirAnnotationCall).also {
dataFlowAnalyzer.exitAnnotationCall(it)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt
+2 -1
View File
@@ -6,6 +6,7 @@
package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
abstract class FirPartialBodyResolveTransformer(
@@ -20,7 +21,7 @@ abstract class FirPartialBodyResolveTransformer(
transformer.implicitTypeOnly = value
}
override fun <E : FirElement> transformElement(element: E, data: Any?): CompositeTransformResult<E> {
override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): CompositeTransformResult<E> {
return element.transform(transformer, data)
}
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt
+2 -1
View File
@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.psi
import org.jetbrains.kotlin.fir.references.*
import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.resolve.FirProvider
import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformer
import org.jetbrains.kotlin.fir.resolve.transformers.runResolve
import org.jetbrains.kotlin.fir.scopes.ProcessorAction
@@ -143,7 +144,7 @@ private fun FirDeclaration.runResolve(
designation.iterator(), state.getSession(psi as KtElement),
implicitTypeOnly = toPhase == FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE
)
file.transform<FirFile, Nothing?>(transformer, null)
file.transform<FirFile, ResolutionMode>(transformer, ResolutionMode.ContextDependent)
}
}