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

FIR: Get rid of CompositeTransformResult

Browse Source
This commit is contained in:
Ilya Chernikov
2021-04-09 16:38:44 +02:00
parent 00df2c4a9e
commit dfd5e80ce9
52 changed files with 913 additions and 1108 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/analysis-tests/testData/resolve/problems/transform.fir.txt
Vendored
+4 -50
View File
@@ -1,50 +1,4 @@
FILE: transform.kt FILE: transform.kt
public sealed class CompositeTransformResult<out T : R|kotlin/Any|> : R|kotlin/Any| {
protected constructor<out T : R|kotlin/Any|>(): R|CompositeTransformResult<T>| {
super<R|kotlin/Any|>()
}
public final class Single<out T : R|kotlin/Any|> : R|CompositeTransformResult<T>| {
public constructor<out T : R|kotlin/Any|>(_single: R|T|): R|CompositeTransformResult.Single<T>| {
super<R|CompositeTransformResult<T>|>()
}
public final val _single: R|T| = R|<local>/_single|
public get(): R|T|
}
public final class Multiple<out T : R|kotlin/Any|> : R|CompositeTransformResult<T>| {
public constructor<out T : R|kotlin/Any|>(_list: R|kotlin/collections/List<T>|): R|CompositeTransformResult.Multiple<T>| {
super<R|CompositeTransformResult<T>|>()
}
public final val _list: R|kotlin/collections/List<T>| = R|<local>/_list|
public get(): R|kotlin/collections/List<T>|
}
public final companion object Companion : R|kotlin/Any| {
private constructor(): R|CompositeTransformResult.Companion| {
super<R|kotlin/Any|>()
}
public final fun <T : R|kotlin/Any|> single(t: R|T|): R|CompositeTransformResult.Single<T>| {
^single R|SubstitutionOverride</CompositeTransformResult.Single.Single>|<R|T|>(R|<local>/t|)
}
public final fun <T : R|kotlin/Any|> many(l: R|kotlin/collections/List<T>|): R|CompositeTransformResult.Multiple<T>| {
^many R|SubstitutionOverride</CompositeTransformResult.Multiple.Multiple>|<R|T|>(R|<local>/l|)
}
}
public final val single: R|T|
public get(): R|T| {
^ ((this@R|/CompositeTransformResult| as R|CompositeTransformResult.Single<*>|).R|SubstitutionOverride</CompositeTransformResult.Single._single: R|CapturedType(*)|>| as R|T|)
}
}
public abstract interface FirElement : R|kotlin/Any| { public abstract interface FirElement : R|kotlin/Any| {
public abstract fun <R, D> accept(visitor: R|FirVisitor<R, D>|, data: R|D|): R|R| public abstract fun <R, D> accept(visitor: R|FirVisitor<R, D>|, data: R|D|): R|R|
@@ -52,7 +6,7 @@ FILE: transform.kt
^accept this@R|/FirElement|.R|/FirElement.accept|<R|kotlin/Unit|, R|kotlin/Nothing?|>(R|<local>/visitor|, Null(null)) ^accept this@R|/FirElement|.R|/FirElement.accept|<R|kotlin/Unit|, R|kotlin/Nothing?|>(R|<local>/visitor|, Null(null))
} }
public abstract fun <E : R|FirElement|, D> transform(visitor: R|FirTransformer<D>|, data: R|D|): R|CompositeTransformResult<E>| public abstract fun <E : R|FirElement|, D> transform(visitor: R|FirTransformer<D>|, data: R|D|): R|E|
} }
public abstract class FirVisitor<out R, in D> : R|kotlin/Any| { public abstract class FirVisitor<out R, in D> : R|kotlin/Any| {
@@ -67,9 +21,9 @@ FILE: transform.kt
} }
} }
public abstract class FirTransformer<in D> : R|FirVisitor<CompositeTransformResult<FirElement>, D>| { public abstract class FirTransformer<in D> : R|FirVisitor<FirElement, D>| {
public constructor<in D>(): R|FirTransformer<D>| { public constructor<in D>(): R|FirTransformer<D>| {
super<R|FirVisitor<CompositeTransformResult<FirElement>, D>|>() super<R|FirVisitor<FirElement, D>|>()
} }
} }
@@ -109,7 +63,7 @@ FILE: transform.kt
} }
public final fun <F : R|FirClass<F>|> R|F|.runSupertypeResolvePhaseForLocalClass(): R|F| { public final fun <F : R|FirClass<F>|> R|F|.runSupertypeResolvePhaseForLocalClass(): R|F| {
lval applySupertypesTransformer: R|FirApplySupertypesTransformer| = R|/FirApplySupertypesTransformer.FirApplySupertypesTransformer|() lval applySupertypesTransformer: R|FirApplySupertypesTransformer| = R|/FirApplySupertypesTransformer.FirApplySupertypesTransformer|()
^runSupertypeResolvePhaseForLocalClass this@R|/runSupertypeResolvePhaseForLocalClass|.R|SubstitutionOverride</FirClass.transform: R|CompositeTransformResult<E>|>|<R|F|, R|kotlin/Nothing?|>(R|<local>/applySupertypesTransformer|, Null(null)).R|SubstitutionOverride</CompositeTransformResult.single: R|F|>| ^runSupertypeResolvePhaseForLocalClass this@R|/runSupertypeResolvePhaseForLocalClass|.R|SubstitutionOverride</FirClass.transform: R|E|>|<R|F|, R|kotlin/Nothing?|>(R|<local>/applySupertypesTransformer|, Null(null))
} }
public abstract class FirPureAbstractElement : R|FirElement| { public abstract class FirPureAbstractElement : R|FirElement| {
public constructor(): R|FirPureAbstractElement| { public constructor(): R|FirPureAbstractElement| {
compiler/fir/analysis-tests/testData/resolve/problems/transform.kt
Vendored
+3 -18
View File
@@ -1,31 +1,16 @@
sealed class CompositeTransformResult<out T : Any> {
class Single<out T : Any>(val _single: T) : CompositeTransformResult<T>()
class Multiple<out T : Any>(val _list: List<T>) : CompositeTransformResult<T>()
companion object {
fun <T : Any> single(t: T) = Single(t)
fun <T : Any> many(l: List<T>) = Multiple(l)
}
val single: T
get() = (this as Single<*>)._single as T
}
interface FirElement { interface FirElement {
fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R
fun accept(visitor: FirVisitorVoid) = accept(visitor, null) fun accept(visitor: FirVisitorVoid) = accept(visitor, null)
fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): CompositeTransformResult<E> fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): E
} }
abstract class FirVisitor<out R, in D> abstract class FirVisitor<out R, in D>
abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>()
abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirElement>, D>() abstract class FirTransformer<in D> : FirVisitor<FirElement, D>()
interface FirAnnotationContainer : FirElement { interface FirAnnotationContainer : FirElement {
abstract override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R abstract override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R
@@ -59,7 +44,7 @@ private class FirApplySupertypesTransformer() : FirTransformer<Nothing?>()
fun <F : FirClass<F>> F.runSupertypeResolvePhaseForLocalClass(): F { fun <F : FirClass<F>> F.runSupertypeResolvePhaseForLocalClass(): F {
val applySupertypesTransformer = FirApplySupertypesTransformer() val applySupertypesTransformer = FirApplySupertypesTransformer()
return this.transform<F, Nothing?>(applySupertypesTransformer, null).single return this.transform<F, Nothing?>(applySupertypesTransformer, null)
} }
abstract class FirPureAbstractElement : FirElement abstract class FirPureAbstractElement : FirElement
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/FirCheckersResolveProcessor.kt
+4 -6
View File
@@ -13,9 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
class FirCheckersResolveProcessor( class FirCheckersResolveProcessor(
session: FirSession, session: FirSession,
@@ -27,12 +25,12 @@ class FirCheckersResolveProcessor(
} }
class FirCheckersRunnerTransformer(private val diagnosticCollector: AbstractDiagnosticCollector) : FirTransformer<Nothing?>() { class FirCheckersRunnerTransformer(private val diagnosticCollector: AbstractDiagnosticCollector) : FirTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
diagnosticCollector.collectDiagnostics(file) diagnosticCollector.collectDiagnostics(file)
return file.compose() return file
} }
} }
compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt
+2 -3
View File
@@ -28,7 +28,6 @@ import org.jetbrains.kotlin.fir.session.FirSessionFactory
import org.jetbrains.kotlin.fir.types.FirTypeProjection import org.jetbrains.kotlin.fir.types.FirTypeProjection
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.isExtensionFunctionAnnotationCall import org.jetbrains.kotlin.fir.types.isExtensionFunctionAnnotationCall
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
import org.jetbrains.kotlin.parsing.KotlinParserDefinition import org.jetbrains.kotlin.parsing.KotlinParserDefinition
@@ -148,13 +147,13 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
private class ConsistencyTransformer : FirTransformer<Unit>() { private class ConsistencyTransformer : FirTransformer<Unit>() {
var result = hashSetOf<FirElement>() var result = hashSetOf<FirElement>()
override fun <E : FirElement> transformElement(element: E, data: Unit): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Unit): E {
if (!result.add(element)) { if (!result.add(element)) {
throwTwiceVisitingError(element) throwTwiceVisitingError(element)
} else { } else {
element.transformChildren(this, Unit) element.transformChildren(this, Unit)
} }
return CompositeTransformResult.single(element) return element
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt
+7 -9
View File
@@ -15,9 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.calls.Candidate
import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.fir.visitors.transformSingle
import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.resolve.calls.inference.buildAbstractResultingSubstitutor import org.jetbrains.kotlin.resolve.calls.inference.buildAbstractResultingSubstitutor
@@ -257,18 +255,18 @@ class FirStubTypeTransformer(
private val substitutor: ConeSubstitutor private val substitutor: ConeSubstitutor
) : FirDefaultTransformer<Nothing?>() { ) : FirDefaultTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return (element.transformChildren(this, data) as E).compose() return (element.transformChildren(this, data) as E)
} }
override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> = override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?): FirTypeRef =
substitutor.substituteOrNull(resolvedTypeRef.type)?.let { substitutor.substituteOrNull(resolvedTypeRef.type)?.let {
resolvedTypeRef.withReplacedConeType(it).compose() resolvedTypeRef.withReplacedConeType(it)
} ?: resolvedTypeRef.compose() } ?: resolvedTypeRef
override fun transformArgumentList(argumentList: FirArgumentList, data: Nothing?): CompositeTransformResult<FirArgumentList> = override fun transformArgumentList(argumentList: FirArgumentList, data: Nothing?): FirArgumentList =
argumentList.transformArguments(this, data).compose() argumentList.transformArguments(this, data)
} }
private val BUILDER_INFERENCE_ANNOTATION_CLASS_ID = ClassId.topLevel(BUILDER_INFERENCE_ANNOTATION_FQ_NAME) private val BUILDER_INFERENCE_ANNOTATION_CLASS_ID = ClassId.topLevel(BUILDER_INFERENCE_ANNOTATION_FQ_NAME)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractPhaseTransformer.kt
+3 -5
View File
@@ -9,8 +9,6 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
abstract class FirAbstractPhaseTransformer<D>( abstract class FirAbstractPhaseTransformer<D>(
@@ -27,15 +25,15 @@ abstract class FirAbstractPhaseTransformer<D>(
} }
} }
override fun transformFile(file: FirFile, data: D): CompositeTransformResult<FirFile> { override fun transformFile(file: FirFile, data: D): FirFile {
checkSessionConsistency(file) checkSessionConsistency(file)
file.replaceResolvePhase(transformerPhase) file.replaceResolvePhase(transformerPhase)
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return super.transformFile(file, data) as CompositeTransformResult<FirFile> return super.transformFile(file, data) as FirFile
} }
override fun transformDeclaration(declaration: FirDeclaration, data: D): CompositeTransformResult<FirDeclaration> { override fun transformDeclaration(declaration: FirDeclaration, data: D): FirDeclaration {
declaration.replaceResolvePhase(transformerPhase) declaration.replaceResolvePhase(transformerPhase)
return super.transformDeclaration(declaration, data) return super.transformDeclaration(declaration, data)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformer.kt
+2 -4
View File
@@ -7,12 +7,10 @@ package org.jetbrains.kotlin.fir.resolve.transformers
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
abstract class FirAbstractTreeTransformer<D>(phase: FirResolvePhase) : FirAbstractPhaseTransformer<D>(phase) { abstract class FirAbstractTreeTransformer<D>(phase: FirResolvePhase) : FirAbstractPhaseTransformer<D>(phase) {
override fun <E : FirElement> transformElement(element: E, data: D): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: D): E {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return (element.transformChildren(this, data) as E).compose() return (element.transformChildren(this, data) as E)
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt
+1 -2
View File
@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.fir.scopes.impl.wrapNestedClassifierScopeWithSubstit
import org.jetbrains.kotlin.fir.types.ConeClassErrorType import org.jetbrains.kotlin.fir.types.ConeClassErrorType
import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
abstract class FirAbstractTreeTransformerWithSuperTypes( abstract class FirAbstractTreeTransformerWithSuperTypes(
phase: FirResolvePhase, phase: FirResolvePhase,
@@ -50,7 +49,7 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
protected fun resolveNestedClassesSupertypes( protected fun resolveNestedClassesSupertypes(
firClass: FirClass<*>, firClass: FirClass<*>,
data: Nothing? data: Nothing?
): CompositeTransformResult<FirStatement> { ): FirStatement {
firClass.replaceResolvePhase(transformerPhase) firClass.replaceResolvePhase(transformerPhase)
return withScopeCleanup { return withScopeCleanup {
// Otherwise annotations may try to resolve // Otherwise annotations may try to resolve
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt
+62 -63
View File
@@ -123,14 +123,14 @@ class FirCallCompletionResultsWriterTransformer(
override fun transformQualifiedAccessExpression( override fun transformQualifiedAccessExpression(
qualifiedAccessExpression: FirQualifiedAccessExpression, qualifiedAccessExpression: FirQualifiedAccessExpression,
data: ExpectedArgumentType?, data: ExpectedArgumentType?,
): CompositeTransformResult<FirStatement> { ): FirStatement {
val calleeReference = qualifiedAccessExpression.calleeReference as? FirNamedReferenceWithCandidate val calleeReference = qualifiedAccessExpression.calleeReference as? FirNamedReferenceWithCandidate
?: return run { ?: return run {
if (mode == Mode.DelegatedPropertyCompletion) { if (mode == Mode.DelegatedPropertyCompletion) {
val typeUpdater = TypeUpdaterForDelegateArguments() val typeUpdater = TypeUpdaterForDelegateArguments()
qualifiedAccessExpression.transformSingle(typeUpdater, null) qualifiedAccessExpression.transformSingle(typeUpdater, null)
} }
qualifiedAccessExpression.compose() qualifiedAccessExpression
} }
val result = prepareQualifiedTransform(qualifiedAccessExpression, calleeReference) val result = prepareQualifiedTransform(qualifiedAccessExpression, calleeReference)
val typeRef = result.typeRef as FirResolvedTypeRef val typeRef = result.typeRef as FirResolvedTypeRef
@@ -147,12 +147,12 @@ class FirCallCompletionResultsWriterTransformer(
result.transformExplicitReceiver(typeUpdater, null) result.transformExplicitReceiver(typeUpdater, null)
} }
return result.compose() return result
} }
override fun transformFunctionCall(functionCall: FirFunctionCall, data: ExpectedArgumentType?): CompositeTransformResult<FirStatement> { override fun transformFunctionCall(functionCall: FirFunctionCall, data: ExpectedArgumentType?): FirStatement {
val calleeReference = functionCall.calleeReference as? FirNamedReferenceWithCandidate val calleeReference = functionCall.calleeReference as? FirNamedReferenceWithCandidate
?: return functionCall.compose() ?: return functionCall
var result = prepareQualifiedTransform(functionCall, calleeReference) var result = prepareQualifiedTransform(functionCall, calleeReference)
val typeRef = result.typeRef as FirResolvedTypeRef val typeRef = result.typeRef as FirResolvedTypeRef
val subCandidate = calleeReference.candidate val subCandidate = calleeReference.candidate
@@ -209,11 +209,11 @@ class FirCallCompletionResultsWriterTransformer(
if (enableArrayOfCallTransformation) { if (enableArrayOfCallTransformation) {
arrayOfCallTransformer.toArrayOfCall(result)?.let { arrayOfCallTransformer.toArrayOfCall(result)?.let {
return it.compose() return it
} }
} }
return result.compose() return result
} }
private val AbstractFirBasedSymbol<*>.isArrayConstructorWithLambda: Boolean private val AbstractFirBasedSymbol<*>.isArrayConstructorWithLambda: Boolean
@@ -226,9 +226,9 @@ class FirCallCompletionResultsWriterTransformer(
override fun transformAnnotationCall( override fun transformAnnotationCall(
annotationCall: FirAnnotationCall, annotationCall: FirAnnotationCall,
data: ExpectedArgumentType? data: ExpectedArgumentType?
): CompositeTransformResult<FirStatement> { ): FirStatement {
val calleeReference = annotationCall.calleeReference as? FirNamedReferenceWithCandidate val calleeReference = annotationCall.calleeReference as? FirNamedReferenceWithCandidate
?: return annotationCall.compose() ?: return annotationCall
annotationCall.transformCalleeReference( annotationCall.transformCalleeReference(
StoreCalleeReference, StoreCalleeReference,
calleeReference.toResolvedReference(), calleeReference.toResolvedReference(),
@@ -256,7 +256,7 @@ class FirCallCompletionResultsWriterTransformer(
annotationCall.replaceArgumentList(buildResolvedArgumentList(it)) annotationCall.replaceArgumentList(buildResolvedArgumentList(it))
} }
} }
return annotationCall.compose() return annotationCall
} }
private fun Candidate.handleVarargs() { private fun Candidate.handleVarargs() {
@@ -295,7 +295,7 @@ class FirCallCompletionResultsWriterTransformer(
override fun transformSafeCallExpression( override fun transformSafeCallExpression(
safeCallExpression: FirSafeCallExpression, safeCallExpression: FirSafeCallExpression,
data: ExpectedArgumentType? data: ExpectedArgumentType?
): CompositeTransformResult<FirStatement> { ): FirStatement {
safeCallExpression.transformRegularQualifiedAccess( safeCallExpression.transformRegularQualifiedAccess(
this, this,
data?.getExpectedType( data?.getExpectedType(
@@ -305,15 +305,15 @@ class FirCallCompletionResultsWriterTransformer(
safeCallExpression.propagateTypeFromQualifiedAccessAfterNullCheck(safeCallExpression.receiver, session) safeCallExpression.propagateTypeFromQualifiedAccessAfterNullCheck(safeCallExpression.receiver, session)
return safeCallExpression.compose() return safeCallExpression
} }
override fun transformCallableReferenceAccess( override fun transformCallableReferenceAccess(
callableReferenceAccess: FirCallableReferenceAccess, callableReferenceAccess: FirCallableReferenceAccess,
data: ExpectedArgumentType?, data: ExpectedArgumentType?,
): CompositeTransformResult<FirStatement> { ): FirStatement {
val calleeReference = val calleeReference =
callableReferenceAccess.calleeReference as? FirNamedReferenceWithCandidate ?: return callableReferenceAccess.compose() callableReferenceAccess.calleeReference as? FirNamedReferenceWithCandidate ?: return callableReferenceAccess
val subCandidate = calleeReference.candidate val subCandidate = calleeReference.candidate
val typeArguments = computeTypeArguments(callableReferenceAccess, subCandidate) val typeArguments = computeTypeArguments(callableReferenceAccess, subCandidate)
@@ -338,39 +338,38 @@ class FirCallCompletionResultsWriterTransformer(
}, },
).transformDispatchReceiver(StoreReceiver, subCandidate.dispatchReceiverExpression()) ).transformDispatchReceiver(StoreReceiver, subCandidate.dispatchReceiverExpression())
.transformExtensionReceiver(StoreReceiver, subCandidate.extensionReceiverExpression()) .transformExtensionReceiver(StoreReceiver, subCandidate.extensionReceiverExpression())
.compose()
} }
override fun transformVariableAssignment( override fun transformVariableAssignment(
variableAssignment: FirVariableAssignment, variableAssignment: FirVariableAssignment,
data: ExpectedArgumentType?, data: ExpectedArgumentType?,
): CompositeTransformResult<FirStatement> { ): FirStatement {
val calleeReference = variableAssignment.calleeReference as? FirNamedReferenceWithCandidate val calleeReference = variableAssignment.calleeReference as? FirNamedReferenceWithCandidate
?: return variableAssignment.compose() ?: return variableAssignment
val typeArguments = computeTypeArguments(variableAssignment, calleeReference.candidate) val typeArguments = computeTypeArguments(variableAssignment, calleeReference.candidate)
return variableAssignment.transformCalleeReference( return variableAssignment.transformCalleeReference(
StoreCalleeReference, StoreCalleeReference,
calleeReference.toResolvedReference(), calleeReference.toResolvedReference(),
).apply { ).apply {
replaceTypeArguments(typeArguments) replaceTypeArguments(typeArguments)
}.compose() }
} }
private inner class TypeUpdaterForDelegateArguments : FirTransformer<Nothing?>() { private inner class TypeUpdaterForDelegateArguments : FirTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformQualifiedAccessExpression( override fun transformQualifiedAccessExpression(
qualifiedAccessExpression: FirQualifiedAccessExpression, qualifiedAccessExpression: FirQualifiedAccessExpression,
data: Nothing? data: Nothing?
): CompositeTransformResult<FirStatement> { ): FirStatement {
val originalType = qualifiedAccessExpression.typeRef.coneType val originalType = qualifiedAccessExpression.typeRef.coneType
val substitutedReceiverType = finalSubstitutor.substituteOrNull(originalType) ?: return qualifiedAccessExpression.compose() val substitutedReceiverType = finalSubstitutor.substituteOrNull(originalType) ?: return qualifiedAccessExpression
val resolvedTypeRef = qualifiedAccessExpression.typeRef.resolvedTypeFromPrototype(substitutedReceiverType) val resolvedTypeRef = qualifiedAccessExpression.typeRef.resolvedTypeFromPrototype(substitutedReceiverType)
qualifiedAccessExpression.replaceTypeRef(resolvedTypeRef) qualifiedAccessExpression.replaceTypeRef(resolvedTypeRef)
session.lookupTracker?.recordTypeResolveAsLookup(resolvedTypeRef, qualifiedAccessExpression.source, null) session.lookupTracker?.recordTypeResolveAsLookup(resolvedTypeRef, qualifiedAccessExpression.source, null)
return qualifiedAccessExpression.compose() return qualifiedAccessExpression
} }
} }
@@ -400,9 +399,9 @@ class FirCallCompletionResultsWriterTransformer(
override fun transformDelegatedConstructorCall( override fun transformDelegatedConstructorCall(
delegatedConstructorCall: FirDelegatedConstructorCall, delegatedConstructorCall: FirDelegatedConstructorCall,
data: ExpectedArgumentType?, data: ExpectedArgumentType?,
): CompositeTransformResult<FirStatement> { ): FirStatement {
val calleeReference = val calleeReference =
delegatedConstructorCall.calleeReference as? FirNamedReferenceWithCandidate ?: return delegatedConstructorCall.compose() delegatedConstructorCall.calleeReference as? FirNamedReferenceWithCandidate ?: return delegatedConstructorCall
val subCandidate = calleeReference.candidate val subCandidate = calleeReference.candidate
val argumentsMapping = runIf(!calleeReference.isError) { calleeReference.candidate.createArgumentsMapping() } val argumentsMapping = runIf(!calleeReference.isError) { calleeReference.candidate.createArgumentsMapping() }
@@ -420,7 +419,7 @@ class FirCallCompletionResultsWriterTransformer(
return delegatedConstructorCall.transformCalleeReference( return delegatedConstructorCall.transformCalleeReference(
StoreCalleeReference, StoreCalleeReference,
calleeReference.toResolvedReference(), calleeReference.toResolvedReference(),
).compose() )
} }
private fun computeTypeArguments( private fun computeTypeArguments(
@@ -475,7 +474,7 @@ class FirCallCompletionResultsWriterTransformer(
override fun transformAnonymousFunction( override fun transformAnonymousFunction(
anonymousFunction: FirAnonymousFunction, anonymousFunction: FirAnonymousFunction,
data: ExpectedArgumentType?, data: ExpectedArgumentType?,
): CompositeTransformResult<FirStatement> { ): FirStatement {
// This case is not common, and happens when there are anonymous function arguments that aren't mapped to any parameter in the call // This case is not common, and happens when there are anonymous function arguments that aren't mapped to any parameter in the call
// So, we don't run body resolve transformation for them, thus there's no control flow info either // So, we don't run body resolve transformation for them, thus there's no control flow info either
// Control flow info is necessary prerequisite because we collect return expressions in that function // Control flow info is necessary prerequisite because we collect return expressions in that function
@@ -542,7 +541,7 @@ class FirCallCompletionResultsWriterTransformer(
expression.transform<FirElement, ExpectedArgumentType?>(this, finalType?.toExpectedType()) expression.transform<FirElement, ExpectedArgumentType?>(this, finalType?.toExpectedType())
} }
val resultFunction = result.single val resultFunction = result
if (resultFunction.returnTypeRef.coneTypeSafe<ConeIntegerLiteralType>() != null) { if (resultFunction.returnTypeRef.coneTypeSafe<ConeIntegerLiteralType>() != null) {
val lastExpressionType = val lastExpressionType =
(returnExpressionsOfAnonymousFunction.lastOrNull() as? FirExpression) (returnExpressionsOfAnonymousFunction.lastOrNull() as? FirExpression)
@@ -563,44 +562,44 @@ class FirCallCompletionResultsWriterTransformer(
private fun transformImplicitTypeRefInAnonymousFunction( private fun transformImplicitTypeRefInAnonymousFunction(
anonymousFunction: FirAnonymousFunction anonymousFunction: FirAnonymousFunction
): CompositeTransformResult<FirStatement> { ): FirStatement {
val implicitTypeTransformer = object : FirDefaultTransformer<Nothing?>() { val implicitTypeTransformer = object : FirDefaultTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return (element.transformChildren(this, data) as E).compose() return (element.transformChildren(this, data) as E)
} }
override fun transformImplicitTypeRef( override fun transformImplicitTypeRef(
implicitTypeRef: FirImplicitTypeRef, implicitTypeRef: FirImplicitTypeRef,
data: Nothing? data: Nothing?
): CompositeTransformResult<FirTypeRef> = ): FirTypeRef =
buildErrorTypeRef { buildErrorTypeRef {
source = implicitTypeRef.source source = implicitTypeRef.source
// NB: this error message assumes that it is used only if CFG for the anonymous function is not available // NB: this error message assumes that it is used only if CFG for the anonymous function is not available
diagnostic = ConeSimpleDiagnostic("Cannot infer type w/o CFG", DiagnosticKind.InferenceError) diagnostic = ConeSimpleDiagnostic("Cannot infer type w/o CFG", DiagnosticKind.InferenceError)
}.compose() }
} }
// NB: if we transform simply all children, there would be too many type error reports. // NB: if we transform simply all children, there would be too many type error reports.
anonymousFunction.transformReturnTypeRef(implicitTypeTransformer, null) anonymousFunction.transformReturnTypeRef(implicitTypeTransformer, null)
anonymousFunction.transformValueParameters(implicitTypeTransformer, null) anonymousFunction.transformValueParameters(implicitTypeTransformer, null)
anonymousFunction.transformBody(implicitTypeTransformer, null) anonymousFunction.transformBody(implicitTypeTransformer, null)
return anonymousFunction.compose() return anonymousFunction
} }
override fun transformReturnExpression( override fun transformReturnExpression(
returnExpression: FirReturnExpression, returnExpression: FirReturnExpression,
data: ExpectedArgumentType? data: ExpectedArgumentType?
): CompositeTransformResult<FirStatement> { ): FirStatement {
val labeledElement = returnExpression.target.labeledElement val labeledElement = returnExpression.target.labeledElement
if (labeledElement is FirAnonymousFunction) { if (labeledElement is FirAnonymousFunction) {
return returnExpression.compose() return returnExpression
} }
return super.transformReturnExpression(returnExpression, data) return super.transformReturnExpression(returnExpression, data)
} }
override fun transformBlock(block: FirBlock, data: ExpectedArgumentType?): CompositeTransformResult<FirStatement> { override fun transformBlock(block: FirBlock, data: ExpectedArgumentType?): FirStatement {
val initialType = block.resultType.coneTypeSafe<ConeKotlinType>() val initialType = block.resultType.coneTypeSafe<ConeKotlinType>()
if (initialType != null) { if (initialType != null) {
val finalType = finalSubstitutor.substituteOrNull(initialType) val finalType = finalSubstitutor.substituteOrNull(initialType)
@@ -615,7 +614,7 @@ class FirCallCompletionResultsWriterTransformer(
if (block.resultType is FirErrorTypeRef) { if (block.resultType is FirErrorTypeRef) {
block.writeResultType(session) block.writeResultType(session)
} }
return block.compose() return block
} }
// Transformations for synthetic calls generated by FirSyntheticCallGenerator // Transformations for synthetic calls generated by FirSyntheticCallGenerator
@@ -623,41 +622,41 @@ class FirCallCompletionResultsWriterTransformer(
override fun transformWhenExpression( override fun transformWhenExpression(
whenExpression: FirWhenExpression, whenExpression: FirWhenExpression,
data: ExpectedArgumentType? data: ExpectedArgumentType?
): CompositeTransformResult<FirStatement> { ): FirStatement {
return transformSyntheticCall(whenExpression, data) return transformSyntheticCall(whenExpression, data)
} }
override fun transformTryExpression( override fun transformTryExpression(
tryExpression: FirTryExpression, tryExpression: FirTryExpression,
data: ExpectedArgumentType? data: ExpectedArgumentType?
): CompositeTransformResult<FirStatement> { ): FirStatement {
return transformSyntheticCall(tryExpression, data) return transformSyntheticCall(tryExpression, data)
} }
override fun transformCheckNotNullCall( override fun transformCheckNotNullCall(
checkNotNullCall: FirCheckNotNullCall, checkNotNullCall: FirCheckNotNullCall,
data: ExpectedArgumentType? data: ExpectedArgumentType?
): CompositeTransformResult<FirStatement> { ): FirStatement {
return transformSyntheticCall(checkNotNullCall, data) return transformSyntheticCall(checkNotNullCall, data)
} }
override fun transformElvisExpression( override fun transformElvisExpression(
elvisExpression: FirElvisExpression, elvisExpression: FirElvisExpression,
data: ExpectedArgumentType? data: ExpectedArgumentType?
): CompositeTransformResult<FirStatement> { ): FirStatement {
return transformSyntheticCall(elvisExpression, data) return transformSyntheticCall(elvisExpression, data)
} }
private inline fun <reified D> transformSyntheticCall( private inline fun <reified D> transformSyntheticCall(
syntheticCall: D, syntheticCall: D,
data: ExpectedArgumentType?, data: ExpectedArgumentType?,
): CompositeTransformResult<FirStatement> where D : FirResolvable, D : FirExpression { ): FirStatement where D : FirResolvable, D : FirExpression {
val calleeReference = syntheticCall.calleeReference as? FirNamedReferenceWithCandidate val calleeReference = syntheticCall.calleeReference as? FirNamedReferenceWithCandidate
val declaration = calleeReference?.candidate?.symbol?.fir as? FirSimpleFunction val declaration = calleeReference?.candidate?.symbol?.fir as? FirSimpleFunction
if (calleeReference == null || declaration == null) { if (calleeReference == null || declaration == null) {
transformSyntheticCallChildren(syntheticCall, data) transformSyntheticCallChildren(syntheticCall, data)
return syntheticCall.compose() return syntheticCall
} }
val typeRef = typeCalculator.tryCalculateReturnType(declaration) val typeRef = typeCalculator.tryCalculateReturnType(declaration)
@@ -667,7 +666,7 @@ class FirCallCompletionResultsWriterTransformer(
return (syntheticCall.transformCalleeReference( return (syntheticCall.transformCalleeReference(
StoreCalleeReference, StoreCalleeReference,
calleeReference.toResolvedReference(), calleeReference.toResolvedReference(),
) as D).compose() ) as D)
} }
private inline fun <reified D> transformSyntheticCallChildren( private inline fun <reified D> transformSyntheticCallChildren(
@@ -692,20 +691,20 @@ class FirCallCompletionResultsWriterTransformer(
override fun <T> transformConstExpression( override fun <T> transformConstExpression(
constExpression: FirConstExpression<T>, constExpression: FirConstExpression<T>,
data: ExpectedArgumentType?, data: ExpectedArgumentType?,
): CompositeTransformResult<FirStatement> { ): FirStatement {
if (data == ExpectedArgumentType.NoApproximation) return constExpression.compose() if (data == ExpectedArgumentType.NoApproximation) return constExpression
return constExpression.approximateIfIsIntegerConst(data?.getExpectedType(constExpression)).compose() return constExpression.approximateIfIsIntegerConst(data?.getExpectedType(constExpression))
} }
override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: ExpectedArgumentType?): CompositeTransformResult<FirStatement> { override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: ExpectedArgumentType?): FirStatement {
if (arrayOfCall.typeRef !is FirImplicitTypeRef) return arrayOfCall.compose() if (arrayOfCall.typeRef !is FirImplicitTypeRef) return arrayOfCall
val expectedArrayType = data?.getExpectedType(arrayOfCall) val expectedArrayType = data?.getExpectedType(arrayOfCall)
val expectedArrayElementType = expectedArrayType?.arrayElementType() val expectedArrayElementType = expectedArrayType?.arrayElementType()
arrayOfCall.transformChildren(this, expectedArrayElementType?.toExpectedType()) arrayOfCall.transformChildren(this, expectedArrayElementType?.toExpectedType())
val arrayElementType = session.inferenceComponents.ctx.commonSuperTypeOrNull(arrayOfCall.arguments.map { it.typeRef.coneType }) val arrayElementType = session.inferenceComponents.ctx.commonSuperTypeOrNull(arrayOfCall.arguments.map { it.typeRef.coneType })
?: session.builtinTypes.nullableAnyType.type ?: session.builtinTypes.nullableAnyType.type
arrayOfCall.resultType = arrayOfCall.typeRef.resolvedTypeFromPrototype(arrayElementType.createArrayType()) arrayOfCall.resultType = arrayOfCall.typeRef.resolvedTypeFromPrototype(arrayElementType.createArrayType())
return arrayOfCall.compose() return arrayOfCall
} }
private fun FirNamedReferenceWithCandidate.toResolvedReference() = if (this is FirErrorReferenceWithCandidate) { private fun FirNamedReferenceWithCandidate.toResolvedReference() = if (this is FirErrorReferenceWithCandidate) {
@@ -747,45 +746,45 @@ private fun FirExpression.unwrapArgument(): FirExpression = when (this) {
} }
class FirDeclarationCompletionResultsWriter(private val finalSubstitutor: ConeSubstitutor) : FirDefaultTransformer<Nothing?>() { class FirDeclarationCompletionResultsWriter(private val finalSubstitutor: ConeSubstitutor) : FirDefaultTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): FirDeclaration {
simpleFunction.transformReturnTypeRef(this, data) simpleFunction.transformReturnTypeRef(this, data)
simpleFunction.transformValueParameters(this, data) simpleFunction.transformValueParameters(this, data)
simpleFunction.transformReceiverTypeRef(this, data) simpleFunction.transformReceiverTypeRef(this, data)
return simpleFunction.compose() return simpleFunction
} }
override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformProperty(property: FirProperty, data: Nothing?): FirDeclaration {
property.transformGetter(this, data) property.transformGetter(this, data)
property.transformSetter(this, data) property.transformSetter(this, data)
property.transformReturnTypeRef(this, data) property.transformReturnTypeRef(this, data)
property.transformReceiverTypeRef(this, data) property.transformReceiverTypeRef(this, data)
return property.compose() return property
} }
override fun transformPropertyAccessor( override fun transformPropertyAccessor(
propertyAccessor: FirPropertyAccessor, propertyAccessor: FirPropertyAccessor,
data: Nothing? data: Nothing?
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
propertyAccessor.transformReturnTypeRef(this, data) propertyAccessor.transformReturnTypeRef(this, data)
propertyAccessor.transformValueParameters(this, data) propertyAccessor.transformValueParameters(this, data)
return propertyAccessor.compose() return propertyAccessor
} }
override fun transformValueParameter( override fun transformValueParameter(
valueParameter: FirValueParameter, valueParameter: FirValueParameter,
data: Nothing? data: Nothing?
): CompositeTransformResult<FirStatement> { ): FirStatement {
valueParameter.transformReturnTypeRef(this, data) valueParameter.transformReturnTypeRef(this, data)
return valueParameter.compose() return valueParameter
} }
override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> { override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): FirTypeRef {
return finalSubstitutor.substituteOrNull(typeRef.coneType)?.let { return finalSubstitutor.substituteOrNull(typeRef.coneType)?.let {
typeRef.resolvedTypeFromPrototype(it) typeRef.resolvedTypeFromPrototype(it)
}?.compose() ?: typeRef.compose() } ?: typeRef
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt
+10 -12
View File
@@ -16,8 +16,6 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
import org.jetbrains.kotlin.fir.resolve.symbolProvider import org.jetbrains.kotlin.fir.resolve.symbolProvider
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.FqName
@@ -29,8 +27,8 @@ open class FirImportResolveTransformer protected constructor(
final override val session: FirSession, final override val session: FirSession,
phase: FirResolvePhase phase: FirResolvePhase
) : FirAbstractTreeTransformer<Nothing?>(phase) { ) : FirAbstractTreeTransformer<Nothing?>(phase) {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
constructor(session: FirSession) : this(session, FirResolvePhase.IMPORTS) constructor(session: FirSession) : this(session, FirResolvePhase.IMPORTS)
@@ -39,7 +37,7 @@ open class FirImportResolveTransformer protected constructor(
private var currentFile: FirFile? = null private var currentFile: FirFile? = null
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> { override fun transformFile(file: FirFile, data: Nothing?): FirFile {
checkSessionConsistency(file) checkSessionConsistency(file)
file.replaceResolvePhase(transformerPhase) file.replaceResolvePhase(transformerPhase)
return file.also { return file.also {
@@ -50,13 +48,13 @@ open class FirImportResolveTransformer protected constructor(
} finally { } finally {
currentFile = prevValue currentFile = prevValue
} }
}.compose() }
} }
override fun transformImport(import: FirImport, data: Nothing?): CompositeTransformResult<FirImport> { override fun transformImport(import: FirImport, data: Nothing?): FirImport {
val fqName = import.importedFqName?.takeUnless { it.isRoot } ?: return import.compose() val fqName = import.importedFqName?.takeUnless { it.isRoot } ?: return import
if (!fqName.isAcceptable) return import.compose() if (!fqName.isAcceptable) return import
if (import.isAllUnder) { if (import.isAllUnder) {
return transformImportForFqName(fqName, import) return transformImportForFqName(fqName, import)
@@ -72,13 +70,13 @@ open class FirImportResolveTransformer protected constructor(
protected open val FqName.isAcceptable: Boolean protected open val FqName.isAcceptable: Boolean
get() = true get() = true
private fun transformImportForFqName(fqName: FqName, delegate: FirImport): CompositeTransformResult<FirImport> { private fun transformImportForFqName(fqName: FqName, delegate: FirImport): FirImport {
val (packageFqName, relativeClassFqName) = resolveToPackageOrClass(symbolProvider, fqName) ?: return delegate.compose() val (packageFqName, relativeClassFqName) = resolveToPackageOrClass(symbolProvider, fqName) ?: return delegate
return buildResolvedImport { return buildResolvedImport {
this.delegate = delegate this.delegate = delegate
this.packageFqName = packageFqName this.packageFqName = packageFqName
relativeClassName = relativeClassFqName relativeClassName = relativeClassFqName
}.compose() }
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt
+7 -7
View File
@@ -74,23 +74,23 @@ class FirSealedClassInheritorsProcessor(
} }
class InheritorsTransformer(private val inheritorsMap: MutableMap<FirRegularClass, MutableList<ClassId>>) : FirTransformer<Nothing?>() { class InheritorsTransformer(private val inheritorsMap: MutableMap<FirRegularClass, MutableList<ClassId>>) : FirTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
return (file.transformChildren(this, data) as FirFile).compose() return (file.transformChildren(this, data) as FirFile)
} }
override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement {
if (regularClass.modality == Modality.SEALED) { if (regularClass.modality == Modality.SEALED) {
val inheritors = inheritorsMap.remove(regularClass) val inheritors = inheritorsMap.remove(regularClass)
if (inheritors != null) { if (inheritors != null) {
regularClass.setSealedClassInheritors(inheritors) regularClass.setSealedClassInheritors(inheritors)
} }
} }
if (inheritorsMap.isEmpty()) return regularClass.compose() if (inheritorsMap.isEmpty()) return regularClass
return (regularClass.transformChildren(this, data) as FirRegularClass).compose() return (regularClass.transformChildren(this, data) as FirRegularClass)
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt
+9 -11
View File
@@ -15,8 +15,6 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.utils.addToStdlib.safeAs import org.jetbrains.kotlin.utils.addToStdlib.safeAs
class FirSpecificTypeResolverTransformer( class FirSpecificTypeResolverTransformer(
@@ -55,7 +53,7 @@ class FirSpecificTypeResolverTransformer(
} }
@OptIn(PrivateForInline::class) @OptIn(PrivateForInline::class)
override fun transformTypeRef(typeRef: FirTypeRef, data: FirScope): CompositeTransformResult<FirResolvedTypeRef> { override fun transformTypeRef(typeRef: FirTypeRef, data: FirScope): FirResolvedTypeRef {
session.lookupTracker?.recordTypeLookup(typeRef, data.scopeOwnerLookupNames, currentFile?.source) session.lookupTracker?.recordTypeLookup(typeRef, data.scopeOwnerLookupNames, currentFile?.source)
typeRef.transformChildren(this, data) typeRef.transformChildren(this, data)
return transformType(typeRef, typeResolver.resolveType(typeRef, data, areBareTypesAllowed)) return transformType(typeRef, typeResolver.resolveType(typeRef, data, areBareTypesAllowed))
@@ -65,7 +63,7 @@ class FirSpecificTypeResolverTransformer(
override fun transformFunctionTypeRef( override fun transformFunctionTypeRef(
functionTypeRef: FirFunctionTypeRef, functionTypeRef: FirFunctionTypeRef,
data: FirScope data: FirScope
): CompositeTransformResult<FirResolvedTypeRef> { ): FirResolvedTypeRef {
functionTypeRef.transformChildren(this, data) functionTypeRef.transformChildren(this, data)
session.lookupTracker?.recordTypeLookup(functionTypeRef, data.scopeOwnerLookupNames, currentFile?.source) session.lookupTracker?.recordTypeLookup(functionTypeRef, data.scopeOwnerLookupNames, currentFile?.source)
val resolvedType = typeResolver.resolveType(functionTypeRef, data, areBareTypesAllowed).takeIfAcceptable() val resolvedType = typeResolver.resolveType(functionTypeRef, data, areBareTypesAllowed).takeIfAcceptable()
@@ -82,10 +80,10 @@ class FirSpecificTypeResolverTransformer(
diagnostic = (resolvedType as? ConeClassErrorType)?.diagnostic diagnostic = (resolvedType as? ConeClassErrorType)?.diagnostic
?: ConeSimpleDiagnostic("Unresolved functional type: ${functionTypeRef.render()}") ?: ConeSimpleDiagnostic("Unresolved functional type: ${functionTypeRef.render()}")
} }
}.compose() }
} }
private fun transformType(typeRef: FirTypeRef, resolvedType: ConeKotlinType): CompositeTransformResult<FirResolvedTypeRef> { private fun transformType(typeRef: FirTypeRef, resolvedType: ConeKotlinType): FirResolvedTypeRef {
return if (resolvedType !is ConeClassErrorType) { return if (resolvedType !is ConeClassErrorType) {
buildResolvedTypeRef { buildResolvedTypeRef {
source = typeRef.source source = typeRef.source
@@ -113,18 +111,18 @@ class FirSpecificTypeResolverTransformer(
diagnostic = resolvedType.diagnostic diagnostic = resolvedType.diagnostic
} }
}.compose() }
} }
private fun ConeKotlinType.takeIfAcceptable(): ConeKotlinType? = this.takeUnless { private fun ConeKotlinType.takeIfAcceptable(): ConeKotlinType? = this.takeUnless {
!errorTypeAsResolved && it is ConeClassErrorType !errorTypeAsResolved && it is ConeClassErrorType
} }
override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: FirScope): CompositeTransformResult<FirTypeRef> { override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: FirScope): FirTypeRef {
return resolvedTypeRef.compose() return resolvedTypeRef
} }
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: FirScope): CompositeTransformResult<FirTypeRef> { override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: FirScope): FirTypeRef {
return implicitTypeRef.compose() return implicitTypeRef
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt
+29 -31
View File
@@ -18,8 +18,6 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.fir.types.toSymbol import org.jetbrains.kotlin.fir.types.toSymbol
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.fir.visitors.transformSingle
@OptIn(AdapterForResolveProcessor::class) @OptIn(AdapterForResolveProcessor::class)
@@ -52,7 +50,7 @@ fun <F : FirClassLikeDeclaration<F>> F.runStatusResolveForLocalClass(
FirCompositeScope(scopesForLocalClass) FirCompositeScope(scopesForLocalClass)
) )
return this.transform<F, Nothing?>(transformer, null).single return this.transform<F, Nothing?>(transformer, null)
} }
abstract class ResolvedStatusCalculator { abstract class ResolvedStatusCalculator {
@@ -96,7 +94,7 @@ class FirStatusResolveTransformer(
override fun transformRegularClass( override fun transformRegularClass(
regularClass: FirRegularClass, regularClass: FirRegularClass,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirStatement> { ): FirStatement {
val computationStatus = statusComputationSession.startComputing(regularClass) val computationStatus = statusComputationSession.startComputing(regularClass)
forceResolveStatusesOfSupertypes(regularClass) forceResolveStatusesOfSupertypes(regularClass)
/* /*
@@ -155,8 +153,8 @@ private class FirDesignatedStatusResolveTransformer(
override fun transformRegularClass( override fun transformRegularClass(
regularClass: FirRegularClass, regularClass: FirRegularClass,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirStatement> { ): FirStatement {
if (shouldSkipClass(regularClass)) return regularClass.compose() if (shouldSkipClass(regularClass)) return regularClass
regularClass.symbol.ensureResolved(FirResolvePhase.TYPES, session) regularClass.symbol.ensureResolved(FirResolvePhase.TYPES, session)
val classLocated = this.classLocated val classLocated = this.classLocated
/* /*
@@ -255,7 +253,7 @@ abstract class AbstractFirStatusResolveTransformer(
protected abstract fun FirDeclaration.needResolveMembers(): Boolean protected abstract fun FirDeclaration.needResolveMembers(): Boolean
protected abstract fun FirDeclaration.needResolveNestedClassifiers(): Boolean protected abstract fun FirDeclaration.needResolveNestedClassifiers(): Boolean
override fun transformFile(file: FirFile, data: FirResolvedDeclarationStatus?): CompositeTransformResult<FirFile> { override fun transformFile(file: FirFile, data: FirResolvedDeclarationStatus?): FirFile {
file.replaceResolvePhase(transformerPhase) file.replaceResolvePhase(transformerPhase)
if (file.needResolveMembers()) { if (file.needResolveMembers()) {
for (declaration in file.declarations) { for (declaration in file.declarations) {
@@ -271,20 +269,20 @@ abstract class AbstractFirStatusResolveTransformer(
} }
} }
} }
return file.compose() return file
} }
override fun transformDeclarationStatus( override fun transformDeclarationStatus(
declarationStatus: FirDeclarationStatus, declarationStatus: FirDeclarationStatus,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirDeclarationStatus> { ): FirDeclarationStatus {
return (data ?: declarationStatus).compose() return (data ?: declarationStatus)
} }
private inline fun storeClass( private inline fun storeClass(
klass: FirClass<*>, klass: FirClass<*>,
computeResult: () -> CompositeTransformResult<FirDeclaration> computeResult: () -> FirDeclaration
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
classes += klass classes += klass
val result = computeResult() val result = computeResult()
classes.removeAt(classes.lastIndex) classes.removeAt(classes.lastIndex)
@@ -294,7 +292,7 @@ abstract class AbstractFirStatusResolveTransformer(
override fun transformDeclaration( override fun transformDeclaration(
declaration: FirDeclaration, declaration: FirDeclaration,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
declaration.replaceResolvePhase(transformerPhase) declaration.replaceResolvePhase(transformerPhase)
return when (declaration) { return when (declaration) {
is FirCallableDeclaration<*> -> { is FirCallableDeclaration<*> -> {
@@ -305,7 +303,7 @@ abstract class AbstractFirStatusResolveTransformer(
} }
} }
} }
declaration.compose() declaration
} }
else -> { else -> {
transformElement(declaration, data) transformElement(declaration, data)
@@ -316,7 +314,7 @@ abstract class AbstractFirStatusResolveTransformer(
override fun transformTypeAlias( override fun transformTypeAlias(
typeAlias: FirTypeAlias, typeAlias: FirTypeAlias,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
typeAlias.typeParameters.forEach { transformDeclaration(it, data) } typeAlias.typeParameters.forEach { transformDeclaration(it, data) }
typeAlias.transformStatus(this, statusResolver.resolveStatus(typeAlias, containingClass, isLocal = false)) typeAlias.transformStatus(this, statusResolver.resolveStatus(typeAlias, containingClass, isLocal = false))
return transformDeclaration(typeAlias, data) return transformDeclaration(typeAlias, data)
@@ -325,12 +323,12 @@ abstract class AbstractFirStatusResolveTransformer(
abstract override fun transformRegularClass( abstract override fun transformRegularClass(
regularClass: FirRegularClass, regularClass: FirRegularClass,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirStatement> ): FirStatement
override fun transformAnonymousObject( override fun transformAnonymousObject(
anonymousObject: FirAnonymousObject, anonymousObject: FirAnonymousObject,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirStatement> { ): FirStatement {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return transformClass(anonymousObject, data) return transformClass(anonymousObject, data)
} }
@@ -339,7 +337,7 @@ abstract class AbstractFirStatusResolveTransformer(
override fun <F : FirClass<F>> transformClass( override fun <F : FirClass<F>> transformClass(
klass: FirClass<F>, klass: FirClass<F>,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirStatement> { ): FirStatement {
return storeClass(klass) { return storeClass(klass) {
klass.typeParameters.forEach { it.transformSingle(this, data) } klass.typeParameters.forEach { it.transformSingle(this, data) }
klass.replaceResolvePhase(transformerPhase) klass.replaceResolvePhase(transformerPhase)
@@ -355,8 +353,8 @@ abstract class AbstractFirStatusResolveTransformer(
} }
} }
} }
klass.compose() klass
} as CompositeTransformResult<FirStatement> } as FirStatement
} }
protected fun updateResolvePhaseOfMembers(regularClass: FirRegularClass) { protected fun updateResolvePhaseOfMembers(regularClass: FirRegularClass) {
@@ -447,7 +445,7 @@ abstract class AbstractFirStatusResolveTransformer(
override fun transformConstructor( override fun transformConstructor(
constructor: FirConstructor, constructor: FirConstructor,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
constructor.transformStatus(this, statusResolver.resolveStatus(constructor, containingClass, isLocal = false)) constructor.transformStatus(this, statusResolver.resolveStatus(constructor, containingClass, isLocal = false))
return transformDeclaration(constructor, data) return transformDeclaration(constructor, data)
} }
@@ -455,7 +453,7 @@ abstract class AbstractFirStatusResolveTransformer(
override fun transformSimpleFunction( override fun transformSimpleFunction(
simpleFunction: FirSimpleFunction, simpleFunction: FirSimpleFunction,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
simpleFunction.replaceResolvePhase(transformerPhase) simpleFunction.replaceResolvePhase(transformerPhase)
simpleFunction.transformStatus(this, statusResolver.resolveStatus(simpleFunction, containingClass, isLocal = false)) simpleFunction.transformStatus(this, statusResolver.resolveStatus(simpleFunction, containingClass, isLocal = false))
return transformDeclaration(simpleFunction, data) return transformDeclaration(simpleFunction, data)
@@ -464,20 +462,20 @@ abstract class AbstractFirStatusResolveTransformer(
override fun transformProperty( override fun transformProperty(
property: FirProperty, property: FirProperty,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
property.replaceResolvePhase(transformerPhase) property.replaceResolvePhase(transformerPhase)
property.transformStatus(this, statusResolver.resolveStatus(property, containingClass, isLocal = false)) property.transformStatus(this, statusResolver.resolveStatus(property, containingClass, isLocal = false))
property.getter?.let { transformPropertyAccessor(it, property) } property.getter?.let { transformPropertyAccessor(it, property) }
property.setter?.let { transformPropertyAccessor(it, property) } property.setter?.let { transformPropertyAccessor(it, property) }
return property.compose() return property
} }
override fun transformField( override fun transformField(
field: FirField, field: FirField,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
field.transformStatus(this, statusResolver.resolveStatus(field, containingClass, isLocal = false)) field.transformStatus(this, statusResolver.resolveStatus(field, containingClass, isLocal = false))
return transformDeclaration(field, data) return transformDeclaration(field, data)
} }
@@ -485,7 +483,7 @@ abstract class AbstractFirStatusResolveTransformer(
override fun transformEnumEntry( override fun transformEnumEntry(
enumEntry: FirEnumEntry, enumEntry: FirEnumEntry,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
enumEntry.transformStatus(this, statusResolver.resolveStatus(enumEntry, containingClass, isLocal = false)) enumEntry.transformStatus(this, statusResolver.resolveStatus(enumEntry, containingClass, isLocal = false))
return transformDeclaration(enumEntry, data) return transformDeclaration(enumEntry, data)
} }
@@ -493,19 +491,19 @@ abstract class AbstractFirStatusResolveTransformer(
override fun transformValueParameter( override fun transformValueParameter(
valueParameter: FirValueParameter, valueParameter: FirValueParameter,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirStatement> { ): FirStatement {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return transformDeclaration(valueParameter, data) as CompositeTransformResult<FirStatement> return transformDeclaration(valueParameter, data) as FirStatement
} }
override fun transformTypeParameter( override fun transformTypeParameter(
typeParameter: FirTypeParameter, typeParameter: FirTypeParameter,
data: FirResolvedDeclarationStatus? data: FirResolvedDeclarationStatus?
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
return transformDeclaration(typeParameter, data) return transformDeclaration(typeParameter, data)
} }
override fun transformBlock(block: FirBlock, data: FirResolvedDeclarationStatus?): CompositeTransformResult<FirStatement> { override fun transformBlock(block: FirBlock, data: FirResolvedDeclarationStatus?): FirStatement {
return block.compose() return block
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt
+16 -16
View File
@@ -46,11 +46,11 @@ class FirSupertypeResolverTransformer(
private val supertypeResolverVisitor = FirSupertypeResolverVisitor(session, supertypeComputationSession, scopeSession) private val supertypeResolverVisitor = FirSupertypeResolverVisitor(session, supertypeComputationSession, scopeSession)
private val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession) private val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession)
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> { override fun transformFile(file: FirFile, data: Nothing?): FirFile {
checkSessionConsistency(file) checkSessionConsistency(file)
file.accept(supertypeResolverVisitor) file.accept(supertypeResolverVisitor)
supertypeComputationSession.breakLoops(session) supertypeComputationSession.breakLoops(session)
@@ -75,26 +75,26 @@ fun <F : FirClassLikeDeclaration<F>> F.runSupertypeResolvePhaseForLocalClass(
supertypeComputationSession.breakLoops(session) supertypeComputationSession.breakLoops(session)
val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession) val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession)
return this.transform<F, Nothing?>(applySupertypesTransformer, null).single return this.transform<F, Nothing?>(applySupertypesTransformer, null)
} }
private class FirApplySupertypesTransformer( private class FirApplySupertypesTransformer(
private val supertypeComputationSession: SupertypeComputationSession private val supertypeComputationSession: SupertypeComputationSession
) : FirDefaultTransformer<Nothing?>() { ) : FirDefaultTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
file.replaceResolvePhase(FirResolvePhase.SUPER_TYPES) file.replaceResolvePhase(FirResolvePhase.SUPER_TYPES)
return (file.transformChildren(this, null) as FirFile).compose() return (file.transformChildren(this, null) as FirFile)
} }
override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement {
applyResolvedSupertypesToClass(regularClass) applyResolvedSupertypesToClass(regularClass)
return (regularClass.transformChildren(this, null) as FirRegularClass).compose() return (regularClass.transformChildren(this, null) as FirRegularClass)
} }
private fun applyResolvedSupertypesToClass(firClass: FirClass<*>) { private fun applyResolvedSupertypesToClass(firClass: FirClass<*>) {
@@ -107,7 +107,7 @@ private class FirApplySupertypesTransformer(
firClass.replaceResolvePhase(FirResolvePhase.SUPER_TYPES) firClass.replaceResolvePhase(FirResolvePhase.SUPER_TYPES)
} }
override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): FirStatement {
applyResolvedSupertypesToClass(anonymousObject) applyResolvedSupertypesToClass(anonymousObject)
return super.transformAnonymousObject(anonymousObject, data) return super.transformAnonymousObject(anonymousObject, data)
@@ -121,8 +121,8 @@ private class FirApplySupertypesTransformer(
return status.supertypeRefs return status.supertypeRefs
} }
override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): FirDeclaration {
if (typeAlias.expandedTypeRef is FirResolvedTypeRef) return typeAlias.compose() if (typeAlias.expandedTypeRef is FirResolvedTypeRef) return typeAlias
val supertypeRefs = getResolvedSupertypeRefs(typeAlias) val supertypeRefs = getResolvedSupertypeRefs(typeAlias)
assert(supertypeRefs.size == 1) { assert(supertypeRefs.size == 1) {
@@ -133,7 +133,7 @@ private class FirApplySupertypesTransformer(
typeAlias.replaceExpandedTypeRef(supertypeRefs[0]) typeAlias.replaceExpandedTypeRef(supertypeRefs[0])
typeAlias.replaceResolvePhase(FirResolvePhase.SUPER_TYPES) typeAlias.replaceResolvePhase(FirResolvePhase.SUPER_TYPES)
return typeAlias.compose() return typeAlias
} }
} }
@@ -295,7 +295,7 @@ private class FirSupertypeResolverVisitor(
So we create a copy of supertypeRefs to avoid it So we create a copy of supertypeRefs to avoid it
*/ */
supertypeRefs.createCopy().mapTo(mutableListOf()) { supertypeRefs.createCopy().mapTo(mutableListOf()) {
val superTypeRef = transformer.transformTypeRef(it, scope).single val superTypeRef = transformer.transformTypeRef(it, scope)
val typeParameterType = superTypeRef.coneTypeSafe<ConeTypeParameterType>() val typeParameterType = superTypeRef.coneTypeSafe<ConeTypeParameterType>()
when { when {
typeParameterType != null -> typeParameterType != null ->
@@ -334,7 +334,7 @@ private class FirSupertypeResolverVisitor(
resolveSpecificClassLikeSupertypes(typeAlias) { transformer, scope -> resolveSpecificClassLikeSupertypes(typeAlias) { transformer, scope ->
val resolvedTypeRef = val resolvedTypeRef =
transformer.transformTypeRef(typeAlias.expandedTypeRef, scope).single as? FirResolvedTypeRef transformer.transformTypeRef(typeAlias.expandedTypeRef, scope) as? FirResolvedTypeRef
?: return@resolveSpecificClassLikeSupertypes listOf( ?: return@resolveSpecificClassLikeSupertypes listOf(
createErrorTypeRef( createErrorTypeRef(
typeAlias.expandedTypeRef, typeAlias.expandedTypeRef,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt
+4 -6
View File
@@ -33,9 +33,7 @@ import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
import org.jetbrains.kotlin.fir.types.builder.buildTypeProjectionWithVariance import org.jetbrains.kotlin.fir.types.builder.buildTypeProjectionWithVariance
import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
@@ -346,11 +344,11 @@ class FirSyntheticCallGenerator(
} }
private object UpdateReference : FirTransformer<FirNamedReferenceWithCandidate>() { private object UpdateReference : FirTransformer<FirNamedReferenceWithCandidate>() {
override fun <E : FirElement> transformElement(element: E, data: FirNamedReferenceWithCandidate): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: FirNamedReferenceWithCandidate): E {
return element.compose() return element
} }
override fun transformReference(reference: FirReference, data: FirNamedReferenceWithCandidate): CompositeTransformResult<FirReference> { override fun transformReference(reference: FirReference, data: FirNamedReferenceWithCandidate): FirReference {
return data.compose() return data
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt
+26 -28
View File
@@ -16,8 +16,6 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.scopes.createImportingScopes import org.jetbrains.kotlin.fir.scopes.createImportingScopes
import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
class FirTypeResolveProcessor( class FirTypeResolveProcessor(
session: FirSession, session: FirSession,
@@ -33,7 +31,7 @@ fun <F : FirClassLikeDeclaration<F>> F.runTypeResolvePhaseForLocalClass(
): F { ): F {
val transformer = FirTypeResolveTransformer(session, scopeSession, currentScopeList) val transformer = FirTypeResolveTransformer(session, scopeSession, currentScopeList)
return this.transform<F, Nothing?>(transformer, null).single return this.transform<F, Nothing?>(transformer, null)
} }
class FirTypeResolveTransformer( class FirTypeResolveTransformer(
@@ -52,7 +50,7 @@ class FirTypeResolveTransformer(
private val typeResolverTransformer: FirSpecificTypeResolverTransformer = FirSpecificTypeResolverTransformer(session) private val typeResolverTransformer: FirSpecificTypeResolverTransformer = FirSpecificTypeResolverTransformer(session)
private var currentFile: FirFile? = null private var currentFile: FirFile? = null
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> { override fun transformFile(file: FirFile, data: Nothing?): FirFile {
checkSessionConsistency(file) checkSessionConsistency(file)
currentFile = file currentFile = file
return withScopeCleanup { return withScopeCleanup {
@@ -61,7 +59,7 @@ class FirTypeResolveTransformer(
} }
} }
override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement {
withScopeCleanup { withScopeCleanup {
regularClass.addTypeParametersScope() regularClass.addTypeParametersScope()
regularClass.typeParameters.forEach { regularClass.typeParameters.forEach {
@@ -73,33 +71,33 @@ class FirTypeResolveTransformer(
return resolveNestedClassesSupertypes(regularClass, data) return resolveNestedClassesSupertypes(regularClass, data)
} }
override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): FirStatement {
return resolveNestedClassesSupertypes(anonymousObject, data) return resolveNestedClassesSupertypes(anonymousObject, data)
} }
override fun transformConstructor(constructor: FirConstructor, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformConstructor(constructor: FirConstructor, data: Nothing?): FirDeclaration {
return withScopeCleanup { return withScopeCleanup {
constructor.addTypeParametersScope() constructor.addTypeParametersScope()
transformDeclaration(constructor, data) transformDeclaration(constructor, data)
} }
} }
override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): FirDeclaration {
return withScopeCleanup { return withScopeCleanup {
typeAlias.addTypeParametersScope() typeAlias.addTypeParametersScope()
transformDeclaration(typeAlias, data) transformDeclaration(typeAlias, data)
} }
} }
override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): FirDeclaration {
enumEntry.replaceResolvePhase(FirResolvePhase.TYPES) enumEntry.replaceResolvePhase(FirResolvePhase.TYPES)
enumEntry.transformReturnTypeRef(this, data) enumEntry.transformReturnTypeRef(this, data)
enumEntry.transformTypeParameters(this, data) enumEntry.transformTypeParameters(this, data)
enumEntry.transformAnnotations(this, data) enumEntry.transformAnnotations(this, data)
return enumEntry.compose() return enumEntry
} }
override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformProperty(property: FirProperty, data: Nothing?): FirDeclaration {
return withScopeCleanup { return withScopeCleanup {
property.addTypeParametersScope() property.addTypeParametersScope()
property.replaceResolvePhase(FirResolvePhase.TYPES) property.replaceResolvePhase(FirResolvePhase.TYPES)
@@ -117,23 +115,23 @@ class FirTypeResolveTransformer(
unboundCyclesInTypeParametersSupertypes(property) unboundCyclesInTypeParametersSupertypes(property)
property.compose() property
} }
} }
override fun transformField(field: FirField, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformField(field: FirField, data: Nothing?): FirDeclaration {
return withScopeCleanup { return withScopeCleanup {
field.replaceResolvePhase(FirResolvePhase.TYPES) field.replaceResolvePhase(FirResolvePhase.TYPES)
field.transformReturnTypeRef(this, data).transformAnnotations(this, data) field.transformReturnTypeRef(this, data).transformAnnotations(this, data)
field.compose() field
} }
} }
override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): FirDeclaration {
return withScopeCleanup { return withScopeCleanup {
simpleFunction.addTypeParametersScope() simpleFunction.addTypeParametersScope()
transformDeclaration(simpleFunction, data).also { transformDeclaration(simpleFunction, data).also {
unboundCyclesInTypeParametersSupertypes(it.single as FirTypeParametersOwner) unboundCyclesInTypeParametersSupertypes(it as FirTypeParametersOwner)
} }
} }
} }
@@ -165,39 +163,39 @@ class FirTypeResolveTransformer(
} }
} }
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> { override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?): FirTypeRef {
if (implicitTypeRef is FirImplicitBuiltinTypeRef) return transformTypeRef(implicitTypeRef, data) if (implicitTypeRef is FirImplicitBuiltinTypeRef) return transformTypeRef(implicitTypeRef, data)
return implicitTypeRef.compose() return implicitTypeRef
} }
override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult<FirResolvedTypeRef> { override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): FirResolvedTypeRef {
return typeResolverTransformer.withFile(currentFile) { typeRef.transform(typeResolverTransformer, towerScope) } return typeResolverTransformer.withFile(currentFile) { typeRef.transform(typeResolverTransformer, towerScope) }
} }
override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): FirStatement {
valueParameter.transformReturnTypeRef(this, data) valueParameter.transformReturnTypeRef(this, data)
valueParameter.transformAnnotations(this, data) valueParameter.transformAnnotations(this, data)
valueParameter.transformVarargTypeToArrayType() valueParameter.transformVarargTypeToArrayType()
return valueParameter.compose() return valueParameter
} }
override fun transformBlock(block: FirBlock, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformBlock(block: FirBlock, data: Nothing?): FirStatement {
return block.compose() return block
} }
override fun transformDelegatedConstructorCall( override fun transformDelegatedConstructorCall(
delegatedConstructorCall: FirDelegatedConstructorCall, delegatedConstructorCall: FirDelegatedConstructorCall,
data: Nothing? data: Nothing?
): CompositeTransformResult<FirStatement> { ): FirStatement {
delegatedConstructorCall.replaceConstructedTypeRef( delegatedConstructorCall.replaceConstructedTypeRef(
delegatedConstructorCall.constructedTypeRef.transform<FirTypeRef, Nothing?>(this, data).single delegatedConstructorCall.constructedTypeRef.transform<FirTypeRef, Nothing?>(this, data)
) )
delegatedConstructorCall.transformCalleeReference(this, data) delegatedConstructorCall.transformCalleeReference(this, data)
return delegatedConstructorCall.compose() return delegatedConstructorCall
} }
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?): FirStatement {
annotationCall.transformAnnotationTypeRef(this, data) annotationCall.transformAnnotationTypeRef(this, data)
return annotationCall.compose() return annotationCall
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt
+3 -5
View File
@@ -23,10 +23,8 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
import org.jetbrains.kotlin.fir.visitors.compose
class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyResolveComponents) : FirTransformer<Nothing?>() { class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyResolveComponents) : FirTransformer<Nothing?>() {
companion object { companion object {
@@ -37,13 +35,13 @@ class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyRe
) )
} }
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
throw IllegalArgumentException("Should not be there") throw IllegalArgumentException("Should not be there")
} }
override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Nothing?): FirStatement {
processExhaustivenessCheck(whenExpression) processExhaustivenessCheck(whenExpression)
return whenExpression.compose() return whenExpression
} }
@OptIn(ExperimentalStdlibApi::class) @OptIn(ExperimentalStdlibApi::class)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt
+5 -7
View File
@@ -15,9 +15,7 @@ import org.jetbrains.kotlin.fir.types.ConeIntegerLiteralType
import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.coneTypeSafe import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.fir.types.toConstKind import org.jetbrains.kotlin.fir.types.toConstKind
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.fir.visitors.transformSingle
import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.ConstantValueKind
@@ -26,20 +24,20 @@ fun FirExpression.approximateIfIsIntegerConst(expectedType: ConeKotlinType? = nu
} }
private object IntegerLiteralTypeApproximationTransformer : FirTransformer<ConeKotlinType?>() { private object IntegerLiteralTypeApproximationTransformer : FirTransformer<ConeKotlinType?>() {
override fun <E : FirElement> transformElement(element: E, data: ConeKotlinType?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: ConeKotlinType?): E {
return element.compose() return element
} }
override fun <T> transformConstExpression( override fun <T> transformConstExpression(
constExpression: FirConstExpression<T>, constExpression: FirConstExpression<T>,
data: ConeKotlinType? data: ConeKotlinType?
): CompositeTransformResult<FirStatement> { ): FirStatement {
val type = constExpression.resultType.coneTypeSafe<ConeIntegerLiteralType>() ?: return constExpression.compose() val type = constExpression.resultType.coneTypeSafe<ConeIntegerLiteralType>() ?: return constExpression
val approximatedType = type.getApproximatedType(data) val approximatedType = type.getApproximatedType(data)
constExpression.resultType = constExpression.resultType.resolvedTypeFromPrototype(approximatedType) constExpression.resultType = constExpression.resultType.resolvedTypeFromPrototype(approximatedType)
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
val kind = approximatedType.toConstKind() as ConstantValueKind<T> val kind = approximatedType.toConstKind() as ConstantValueKind<T>
constExpression.replaceKind(kind) constExpression.replaceKind(kind)
return constExpression.compose() return constExpression
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt
+19 -21
View File
@@ -14,54 +14,52 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
import org.jetbrains.kotlin.fir.declarations.isInline import org.jetbrains.kotlin.fir.declarations.isInline
import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
object InvocationKindTransformer : FirTransformer<Nothing?>() { object InvocationKindTransformer : FirTransformer<Nothing?>() {
private object ArgumentsTransformer : FirTransformer<Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>>() { private object ArgumentsTransformer : FirTransformer<Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>>() {
override fun <E : FirElement> transformElement(element: E, data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>): E {
return element.compose() return element
} }
override fun transformAnonymousFunction( override fun transformAnonymousFunction(
anonymousFunction: FirAnonymousFunction, anonymousFunction: FirAnonymousFunction,
data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?> data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>
): CompositeTransformResult<FirStatement> { ): FirStatement {
val kind = data.second ?: data.first[anonymousFunction] val kind = data.second ?: data.first[anonymousFunction]
if (kind != null) { if (kind != null) {
anonymousFunction.replaceInvocationKind(kind) anonymousFunction.replaceInvocationKind(kind)
} }
return anonymousFunction.compose() return anonymousFunction
} }
override fun transformLambdaArgumentExpression( override fun transformLambdaArgumentExpression(
lambdaArgumentExpression: FirLambdaArgumentExpression, lambdaArgumentExpression: FirLambdaArgumentExpression,
data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?> data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>
): CompositeTransformResult<FirStatement> { ): FirStatement {
return data.first[lambdaArgumentExpression]?.let { return data.first[lambdaArgumentExpression]?.let {
(lambdaArgumentExpression.transformChildren(this, data.first to it) as FirStatement).compose() (lambdaArgumentExpression.transformChildren(this, data.first to it) as FirStatement)
} ?: lambdaArgumentExpression.compose() } ?: lambdaArgumentExpression
} }
override fun transformNamedArgumentExpression( override fun transformNamedArgumentExpression(
namedArgumentExpression: FirNamedArgumentExpression, namedArgumentExpression: FirNamedArgumentExpression,
data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?> data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>
): CompositeTransformResult<FirStatement> { ): FirStatement {
return data.first[namedArgumentExpression]?.let { return data.first[namedArgumentExpression]?.let {
(namedArgumentExpression.transformChildren(this, data.first to it) as FirStatement).compose() (namedArgumentExpression.transformChildren(this, data.first to it) as FirStatement)
} ?: namedArgumentExpression.compose() } ?: namedArgumentExpression
} }
} }
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformFunctionCall(functionCall: FirFunctionCall, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformFunctionCall(functionCall: FirFunctionCall, data: Nothing?): FirStatement {
val calleeReference = functionCall.calleeReference as? FirNamedReferenceWithCandidate ?: return functionCall.compose() val calleeReference = functionCall.calleeReference as? FirNamedReferenceWithCandidate ?: return functionCall
val argumentMapping = calleeReference.candidate.argumentMapping ?: return functionCall.compose() val argumentMapping = calleeReference.candidate.argumentMapping ?: return functionCall
val function = calleeReference.candidateSymbol.fir as? FirSimpleFunction ?: return functionCall.compose() val function = calleeReference.candidateSymbol.fir as? FirSimpleFunction ?: return functionCall
val callsEffects = function.contractDescription.effects val callsEffects = function.contractDescription.effects
?.map { it.effect } ?.map { it.effect }
@@ -69,7 +67,7 @@ object InvocationKindTransformer : FirTransformer<Nothing?>() {
val isInline = function.isInline val isInline = function.isInline
if (callsEffects.isEmpty() && !isInline) { if (callsEffects.isEmpty() && !isInline) {
return functionCall.compose() return functionCall
} }
val reversedArgumentMapping = argumentMapping.entries.map { (argument, parameter) -> val reversedArgumentMapping = argumentMapping.entries.map { (argument, parameter) ->
@@ -89,9 +87,9 @@ object InvocationKindTransformer : FirTransformer<Nothing?>() {
} }
} }
if (invocationKindMapping.isEmpty()) { if (invocationKindMapping.isEmpty()) {
return functionCall.compose() return functionCall
} }
functionCall.argumentList.transformArguments(ArgumentsTransformer, invocationKindMapping to null) functionCall.argumentList.transformArguments(ArgumentsTransformer, invocationKindMapping to null)
return functionCall.compose() return functionCall
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt
+2 -4
View File
@@ -14,9 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolve
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitTypeBodyResolveProcessor import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitTypeBodyResolveProcessor
import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveProcessor import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveProcessor
import org.jetbrains.kotlin.fir.resolve.transformers.plugin.* import org.jetbrains.kotlin.fir.resolve.transformers.plugin.*
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
fun FirResolvePhase.createCompilerProcessorByPhase( fun FirResolvePhase.createCompilerProcessorByPhase(
session: FirSession, session: FirSession,
@@ -48,8 +46,8 @@ class FirDummyTransformerBasedProcessor(
get() = DummyTransformer get() = DummyTransformer
private object DummyTransformer : FirTransformer<Nothing?>() { private object DummyTransformer : FirTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt
+24 -26
View File
@@ -14,83 +14,81 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.references.* import org.jetbrains.kotlin.fir.references.*
import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
internal object StoreType : FirDefaultTransformer<FirTypeRef>() { internal object StoreType : FirDefaultTransformer<FirTypeRef>() {
override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): E {
return element.compose() return element
} }
override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): CompositeTransformResult<FirTypeRef> { override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): FirTypeRef {
return data.compose() return data
} }
} }
internal object TransformImplicitType : FirDefaultTransformer<FirTypeRef>() { internal object TransformImplicitType : FirDefaultTransformer<FirTypeRef>() {
override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): E {
return element.compose() return element
} }
override fun transformImplicitTypeRef( override fun transformImplicitTypeRef(
implicitTypeRef: FirImplicitTypeRef, implicitTypeRef: FirImplicitTypeRef,
data: FirTypeRef data: FirTypeRef
): CompositeTransformResult<FirTypeRef> { ): FirTypeRef {
return data.compose() return data
} }
} }
internal object StoreNameReference : FirDefaultTransformer<FirNamedReference>() { internal object StoreNameReference : FirDefaultTransformer<FirNamedReference>() {
override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): E {
return element.compose() return element
} }
override fun transformNamedReference( override fun transformNamedReference(
namedReference: FirNamedReference, namedReference: FirNamedReference,
data: FirNamedReference data: FirNamedReference
): CompositeTransformResult<FirNamedReference> { ): FirNamedReference {
return data.compose() return data
} }
override fun transformThisReference(thisReference: FirThisReference, data: FirNamedReference): CompositeTransformResult<FirReference> { override fun transformThisReference(thisReference: FirThisReference, data: FirNamedReference): FirReference {
return data.compose() return data
} }
override fun transformSuperReference( override fun transformSuperReference(
superReference: FirSuperReference, superReference: FirSuperReference,
data: FirNamedReference data: FirNamedReference
): CompositeTransformResult<FirReference> { ): FirReference {
return data.compose() return data
} }
} }
internal object StoreCalleeReference : FirTransformer<FirNamedReference>() { internal object StoreCalleeReference : FirTransformer<FirNamedReference>() {
override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): E {
return element.compose() return element
} }
override fun transformNamedReference( override fun transformNamedReference(
namedReference: FirNamedReference, namedReference: FirNamedReference,
data: FirNamedReference data: FirNamedReference
): CompositeTransformResult<FirNamedReference> { ): FirNamedReference {
return data.compose() return data
} }
override fun transformResolvedNamedReference( override fun transformResolvedNamedReference(
resolvedNamedReference: FirResolvedNamedReference, resolvedNamedReference: FirResolvedNamedReference,
data: FirNamedReference data: FirNamedReference
): CompositeTransformResult<FirNamedReference> { ): FirNamedReference {
return data.compose() return data
} }
} }
internal object StoreReceiver : FirTransformer<FirExpression>() { internal object StoreReceiver : FirTransformer<FirExpression>() {
override fun <E : FirElement> transformElement(element: E, data: FirExpression): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: FirExpression): E {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return (data as E).compose() return (data as E)
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt
+58 -60
View File
@@ -22,9 +22,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.createCurrentScopeList
import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
open class FirBodyResolveTransformer( open class FirBodyResolveTransformer(
session: FirSession, session: FirSession,
@@ -46,35 +44,35 @@ open class FirBodyResolveTransformer(
protected open val declarationsTransformer = FirDeclarationsResolveTransformer(this) protected open val declarationsTransformer = FirDeclarationsResolveTransformer(this)
private val controlFlowStatementsTransformer = FirControlFlowStatementsResolveTransformer(this) private val controlFlowStatementsTransformer = FirControlFlowStatementsResolveTransformer(this)
override fun transformFile(file: FirFile, data: ResolutionMode): CompositeTransformResult<FirFile> { override fun transformFile(file: FirFile, data: ResolutionMode): FirFile {
checkSessionConsistency(file) checkSessionConsistency(file)
return context.withFile(file, components) { return context.withFile(file, components) {
onBeforeFileContentResolution(file) onBeforeFileContentResolution(file)
file.replaceResolvePhase(transformerPhase) file.replaceResolvePhase(transformerPhase)
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
transformDeclarationContent(file, data) as CompositeTransformResult<FirFile> transformDeclarationContent(file, data) as FirFile
} }
} }
override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): E {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return (element.transformChildren(this, data) as E).compose() return (element.transformChildren(this, data) as E)
} }
override fun transformTypeRef(typeRef: FirTypeRef, data: ResolutionMode): CompositeTransformResult<FirResolvedTypeRef> { override fun transformTypeRef(typeRef: FirTypeRef, data: ResolutionMode): FirResolvedTypeRef {
if (typeRef is FirResolvedTypeRef) { if (typeRef is FirResolvedTypeRef) {
return typeRef.compose() return typeRef
} }
return typeResolverTransformer.withFile(context.file) { return typeResolverTransformer.withFile(context.file) {
transformTypeRef(typeRef, FirCompositeScope(components.createCurrentScopeList())) transformTypeRef(typeRef, FirCompositeScope(components.createCurrentScopeList()))
} }
} }
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: ResolutionMode): CompositeTransformResult<FirTypeRef> { override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: ResolutionMode): FirTypeRef {
if (data !is ResolutionMode.WithExpectedType) if (data !is ResolutionMode.WithExpectedType)
return implicitTypeRef.compose() return implicitTypeRef
return data.expectedTypeRef.compose() return data.expectedTypeRef
} }
open fun onBeforeFileContentResolution(file: FirFile) {} open fun onBeforeFileContentResolution(file: FirFile) {}
@@ -85,282 +83,282 @@ open class FirBodyResolveTransformer(
// ------------------------------------- Expressions ------------------------------------- // ------------------------------------- Expressions -------------------------------------
override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement {
return expressionsTransformer.transformExpression(expression, data) return expressionsTransformer.transformExpression(expression, data)
} }
override fun transformWrappedArgumentExpression( override fun transformWrappedArgumentExpression(
wrappedArgumentExpression: FirWrappedArgumentExpression, wrappedArgumentExpression: FirWrappedArgumentExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return transformElement(wrappedArgumentExpression, data) return transformElement(wrappedArgumentExpression, data)
} }
override fun transformQualifiedAccessExpression( override fun transformQualifiedAccessExpression(
qualifiedAccessExpression: FirQualifiedAccessExpression, qualifiedAccessExpression: FirQualifiedAccessExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformQualifiedAccessExpression(qualifiedAccessExpression, data) return expressionsTransformer.transformQualifiedAccessExpression(qualifiedAccessExpression, data)
} }
override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): FirStatement {
return expressionsTransformer.transformFunctionCall(functionCall, data) return expressionsTransformer.transformFunctionCall(functionCall, data)
} }
override fun transformCallableReferenceAccess( override fun transformCallableReferenceAccess(
callableReferenceAccess: FirCallableReferenceAccess, callableReferenceAccess: FirCallableReferenceAccess,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformCallableReferenceAccess(callableReferenceAccess, data) return expressionsTransformer.transformCallableReferenceAccess(callableReferenceAccess, data)
} }
override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformBlock(block: FirBlock, data: ResolutionMode): FirStatement {
return expressionsTransformer.transformBlock(block, data) return expressionsTransformer.transformBlock(block, data)
} }
override fun transformThisReceiverExpression( override fun transformThisReceiverExpression(
thisReceiverExpression: FirThisReceiverExpression, thisReceiverExpression: FirThisReceiverExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformThisReceiverExpression(thisReceiverExpression, data) return expressionsTransformer.transformThisReceiverExpression(thisReceiverExpression, data)
} }
override fun transformComparisonExpression( override fun transformComparisonExpression(
comparisonExpression: FirComparisonExpression, comparisonExpression: FirComparisonExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformComparisonExpression(comparisonExpression, data) return expressionsTransformer.transformComparisonExpression(comparisonExpression, data)
} }
override fun transformTypeOperatorCall( override fun transformTypeOperatorCall(
typeOperatorCall: FirTypeOperatorCall, typeOperatorCall: FirTypeOperatorCall,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformTypeOperatorCall(typeOperatorCall, data) return expressionsTransformer.transformTypeOperatorCall(typeOperatorCall, data)
} }
override fun transformAssignmentOperatorStatement( override fun transformAssignmentOperatorStatement(
assignmentOperatorStatement: FirAssignmentOperatorStatement, assignmentOperatorStatement: FirAssignmentOperatorStatement,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformAssignmentOperatorStatement(assignmentOperatorStatement, data) return expressionsTransformer.transformAssignmentOperatorStatement(assignmentOperatorStatement, data)
} }
override fun transformEqualityOperatorCall( override fun transformEqualityOperatorCall(
equalityOperatorCall: FirEqualityOperatorCall, equalityOperatorCall: FirEqualityOperatorCall,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformEqualityOperatorCall(equalityOperatorCall, data) return expressionsTransformer.transformEqualityOperatorCall(equalityOperatorCall, data)
} }
override fun transformCheckNotNullCall( override fun transformCheckNotNullCall(
checkNotNullCall: FirCheckNotNullCall, checkNotNullCall: FirCheckNotNullCall,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformCheckNotNullCall(checkNotNullCall, data) return expressionsTransformer.transformCheckNotNullCall(checkNotNullCall, data)
} }
override fun transformBinaryLogicExpression( override fun transformBinaryLogicExpression(
binaryLogicExpression: FirBinaryLogicExpression, binaryLogicExpression: FirBinaryLogicExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformBinaryLogicExpression(binaryLogicExpression, data) return expressionsTransformer.transformBinaryLogicExpression(binaryLogicExpression, data)
} }
override fun transformVariableAssignment( override fun transformVariableAssignment(
variableAssignment: FirVariableAssignment, variableAssignment: FirVariableAssignment,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformVariableAssignment(variableAssignment, data) return expressionsTransformer.transformVariableAssignment(variableAssignment, data)
} }
override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): FirStatement {
return expressionsTransformer.transformGetClassCall(getClassCall, data) return expressionsTransformer.transformGetClassCall(getClassCall, data)
} }
override fun transformWrappedDelegateExpression( override fun transformWrappedDelegateExpression(
wrappedDelegateExpression: FirWrappedDelegateExpression, wrappedDelegateExpression: FirWrappedDelegateExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return declarationsTransformer.transformWrappedDelegateExpression(wrappedDelegateExpression, data) return declarationsTransformer.transformWrappedDelegateExpression(wrappedDelegateExpression, data)
} }
override fun <T> transformConstExpression( override fun <T> transformConstExpression(
constExpression: FirConstExpression<T>, constExpression: FirConstExpression<T>,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformConstExpression(constExpression, data) return expressionsTransformer.transformConstExpression(constExpression, data)
} }
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement {
return expressionsTransformer.transformAnnotationCall(annotationCall, data) return expressionsTransformer.transformAnnotationCall(annotationCall, data)
} }
override fun transformDelegatedConstructorCall( override fun transformDelegatedConstructorCall(
delegatedConstructorCall: FirDelegatedConstructorCall, delegatedConstructorCall: FirDelegatedConstructorCall,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformDelegatedConstructorCall(delegatedConstructorCall, data) return expressionsTransformer.transformDelegatedConstructorCall(delegatedConstructorCall, data)
} }
override fun transformAugmentedArraySetCall( override fun transformAugmentedArraySetCall(
augmentedArraySetCall: FirAugmentedArraySetCall, augmentedArraySetCall: FirAugmentedArraySetCall,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformAugmentedArraySetCall(augmentedArraySetCall, data) return expressionsTransformer.transformAugmentedArraySetCall(augmentedArraySetCall, data)
} }
override fun transformSafeCallExpression( override fun transformSafeCallExpression(
safeCallExpression: FirSafeCallExpression, safeCallExpression: FirSafeCallExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformSafeCallExpression(safeCallExpression, data) return expressionsTransformer.transformSafeCallExpression(safeCallExpression, data)
} }
override fun transformCheckedSafeCallSubject( override fun transformCheckedSafeCallSubject(
checkedSafeCallSubject: FirCheckedSafeCallSubject, checkedSafeCallSubject: FirCheckedSafeCallSubject,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return expressionsTransformer.transformCheckedSafeCallSubject(checkedSafeCallSubject, data) return expressionsTransformer.transformCheckedSafeCallSubject(checkedSafeCallSubject, data)
} }
// ------------------------------------- Declarations ------------------------------------- // ------------------------------------- Declarations -------------------------------------
override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration {
return declarationsTransformer.transformDeclaration(declaration, data) return declarationsTransformer.transformDeclaration(declaration, data)
} }
open fun transformDeclarationContent( open fun transformDeclarationContent(
declaration: FirDeclaration, data: ResolutionMode declaration: FirDeclaration, data: ResolutionMode
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
return transformElement(declaration, data) return transformElement(declaration, data)
} }
override fun transformDeclarationStatus( override fun transformDeclarationStatus(
declarationStatus: FirDeclarationStatus, declarationStatus: FirDeclarationStatus,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirDeclarationStatus> { ): FirDeclarationStatus {
return declarationsTransformer.transformDeclarationStatus(declarationStatus, data) return declarationsTransformer.transformDeclarationStatus(declarationStatus, data)
} }
override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirDeclaration {
return declarationsTransformer.transformEnumEntry(enumEntry, data) return declarationsTransformer.transformEnumEntry(enumEntry, data)
} }
override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirProperty> { override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
return declarationsTransformer.transformProperty(property, data) return declarationsTransformer.transformProperty(property, data)
} }
override fun transformField(field: FirField, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformField(field: FirField, data: ResolutionMode): FirDeclaration {
return declarationsTransformer.transformField(field, data) return declarationsTransformer.transformField(field, data)
} }
override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement {
return declarationsTransformer.transformRegularClass(regularClass, data) return declarationsTransformer.transformRegularClass(regularClass, data)
} }
override fun transformAnonymousObject( override fun transformAnonymousObject(
anonymousObject: FirAnonymousObject, anonymousObject: FirAnonymousObject,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return declarationsTransformer.transformAnonymousObject(anonymousObject, data) return declarationsTransformer.transformAnonymousObject(anonymousObject, data)
} }
override fun transformSimpleFunction( override fun transformSimpleFunction(
simpleFunction: FirSimpleFunction, simpleFunction: FirSimpleFunction,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirSimpleFunction> { ): FirSimpleFunction {
return declarationsTransformer.transformSimpleFunction(simpleFunction, data) return declarationsTransformer.transformSimpleFunction(simpleFunction, data)
} }
override fun <F : FirFunction<F>> transformFunction( override fun <F : FirFunction<F>> transformFunction(
function: FirFunction<F>, function: FirFunction<F>,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return declarationsTransformer.transformFunction(function, data) return declarationsTransformer.transformFunction(function, data)
} }
override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration {
return declarationsTransformer.transformConstructor(constructor, data) return declarationsTransformer.transformConstructor(constructor, data)
} }
override fun transformAnonymousInitializer( override fun transformAnonymousInitializer(
anonymousInitializer: FirAnonymousInitializer, anonymousInitializer: FirAnonymousInitializer,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
return declarationsTransformer.transformAnonymousInitializer(anonymousInitializer, data) return declarationsTransformer.transformAnonymousInitializer(anonymousInitializer, data)
} }
override fun transformAnonymousFunction( override fun transformAnonymousFunction(
anonymousFunction: FirAnonymousFunction, anonymousFunction: FirAnonymousFunction,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return declarationsTransformer.transformAnonymousFunction(anonymousFunction, data) return declarationsTransformer.transformAnonymousFunction(anonymousFunction, data)
} }
override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement {
return declarationsTransformer.transformValueParameter(valueParameter, data) return declarationsTransformer.transformValueParameter(valueParameter, data)
} }
override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirDeclaration {
return declarationsTransformer.transformTypeAlias(typeAlias, data) return declarationsTransformer.transformTypeAlias(typeAlias, data)
} }
// ------------------------------------- Control flow statements ------------------------------------- // ------------------------------------- Control flow statements -------------------------------------
override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): FirStatement {
return controlFlowStatementsTransformer.transformWhileLoop(whileLoop, data) return controlFlowStatementsTransformer.transformWhileLoop(whileLoop, data)
} }
override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): FirStatement {
return controlFlowStatementsTransformer.transformDoWhileLoop(doWhileLoop, data) return controlFlowStatementsTransformer.transformDoWhileLoop(doWhileLoop, data)
} }
override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): FirStatement {
return controlFlowStatementsTransformer.transformWhenExpression(whenExpression, data) return controlFlowStatementsTransformer.transformWhenExpression(whenExpression, data)
} }
override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): CompositeTransformResult<FirWhenBranch> { override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): FirWhenBranch {
return controlFlowStatementsTransformer.transformWhenBranch(whenBranch, data) return controlFlowStatementsTransformer.transformWhenBranch(whenBranch, data)
} }
override fun transformWhenSubjectExpression( override fun transformWhenSubjectExpression(
whenSubjectExpression: FirWhenSubjectExpression, whenSubjectExpression: FirWhenSubjectExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return controlFlowStatementsTransformer.transformWhenSubjectExpression(whenSubjectExpression, data) return controlFlowStatementsTransformer.transformWhenSubjectExpression(whenSubjectExpression, data)
} }
override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): FirStatement {
return controlFlowStatementsTransformer.transformTryExpression(tryExpression, data) return controlFlowStatementsTransformer.transformTryExpression(tryExpression, data)
} }
override fun transformCatch(catch: FirCatch, data: ResolutionMode): CompositeTransformResult<FirCatch> { override fun transformCatch(catch: FirCatch, data: ResolutionMode): FirCatch {
return controlFlowStatementsTransformer.transformCatch(catch, data) return controlFlowStatementsTransformer.transformCatch(catch, data)
} }
override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: ResolutionMode): FirStatement {
return controlFlowStatementsTransformer.transformJump(jump, data) return controlFlowStatementsTransformer.transformJump(jump, data)
} }
override fun transformReturnExpression( override fun transformReturnExpression(
returnExpression: FirReturnExpression, returnExpression: FirReturnExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return controlFlowStatementsTransformer.transformReturnExpression(returnExpression, data) return controlFlowStatementsTransformer.transformReturnExpression(returnExpression, data)
} }
override fun transformThrowExpression( override fun transformThrowExpression(
throwExpression: FirThrowExpression, throwExpression: FirThrowExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return controlFlowStatementsTransformer.transformThrowExpression(throwExpression, data) return controlFlowStatementsTransformer.transformThrowExpression(throwExpression, data)
} }
override fun transformElvisExpression( override fun transformElvisExpression(
elvisExpression: FirElvisExpression, elvisExpression: FirElvisExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return controlFlowStatementsTransformer.transformElvisExpression(elvisExpression, data) return controlFlowStatementsTransformer.transformElvisExpression(elvisExpression, data)
} }
@@ -368,6 +366,6 @@ open class FirBodyResolveTransformer(
fun <D> FirElement.visitNoTransform(transformer: FirTransformer<D>, data: D) { fun <D> FirElement.visitNoTransform(transformer: FirTransformer<D>, data: D) {
val result = this.transform<FirElement, D>(transformer, data) val result = this.transform<FirElement, D>(transformer, data)
require(result.single === this) { "become ${result.single}: `${result.single.render()}`, was ${this}: `${this.render()}`" } require(result === this) { "become $result: `${result.render()}`, was ${this}: `${this.render()}`" }
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformerAdapters.kt
+3 -5
View File
@@ -13,9 +13,7 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor
import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
@OptIn(AdapterForResolveProcessor::class) @OptIn(AdapterForResolveProcessor::class)
class FirBodyResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) { class FirBodyResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) {
@@ -31,11 +29,11 @@ class FirBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeS
scopeSession = scopeSession scopeSession = scopeSession
) )
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> { override fun transformFile(file: FirFile, data: Nothing?): FirFile {
return file.transform(transformer, ResolutionMode.ContextIndependent) return file.transform(transformer, ResolutionMode.ContextIndependent)
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt
+26 -28
View File
@@ -19,8 +19,6 @@ import org.jetbrains.kotlin.fir.resolve.withExpectedType
import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.fir.visitors.transformSingle
class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTransformer) : class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTransformer) :
@@ -32,15 +30,15 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
// ------------------------------- Loops ------------------------------- // ------------------------------- Loops -------------------------------
override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): FirStatement {
val context = ResolutionMode.ContextIndependent val context = ResolutionMode.ContextIndependent
return whileLoop.also(dataFlowAnalyzer::enterWhileLoop) return whileLoop.also(dataFlowAnalyzer::enterWhileLoop)
.transformCondition(transformer, context).also(dataFlowAnalyzer::exitWhileLoopCondition) .transformCondition(transformer, context).also(dataFlowAnalyzer::exitWhileLoopCondition)
.transformBlock(transformer, context).also(dataFlowAnalyzer::exitWhileLoop) .transformBlock(transformer, context).also(dataFlowAnalyzer::exitWhileLoop)
.transformOtherChildren(transformer, context).compose() .transformOtherChildren(transformer, context)
} }
override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): FirStatement {
// Do-while has a specific scope structure (its block and condition effectively share the scope) // Do-while has a specific scope structure (its block and condition effectively share the scope)
return context.forBlock { return context.forBlock {
val context = ResolutionMode.ContextIndependent val context = ResolutionMode.ContextIndependent
@@ -50,15 +48,15 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
} }
.also(dataFlowAnalyzer::enterDoWhileLoopCondition).transformCondition(transformer, context) .also(dataFlowAnalyzer::enterDoWhileLoopCondition).transformCondition(transformer, context)
.also(dataFlowAnalyzer::exitDoWhileLoop) .also(dataFlowAnalyzer::exitDoWhileLoop)
.transformOtherChildren(transformer, context).compose() .transformOtherChildren(transformer, context)
} }
} }
// ------------------------------- When expressions ------------------------------- // ------------------------------- When expressions -------------------------------
override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): FirStatement {
if (whenExpression.calleeReference is FirResolvedNamedReference && whenExpression.resultType !is FirImplicitTypeRef) { if (whenExpression.calleeReference is FirResolvedNamedReference && whenExpression.resultType !is FirImplicitTypeRef) {
return whenExpression.compose() return whenExpression
} }
whenExpression.annotations.forEach { it.accept(this, data) } whenExpression.annotations.forEach { it.accept(this, data) }
dataFlowAnalyzer.enterWhenExpression(whenExpression) dataFlowAnalyzer.enterWhenExpression(whenExpression)
@@ -81,7 +79,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
whenExpression.resultType = buildErrorTypeRef { whenExpression.resultType = buildErrorTypeRef {
diagnostic = ConeSimpleDiagnostic("Can't resolve when expression", DiagnosticKind.InferenceError) diagnostic = ConeSimpleDiagnostic("Can't resolve when expression", DiagnosticKind.InferenceError)
} }
return@with whenExpression.compose() return@with whenExpression
} }
val expectedTypeRef = data.expectedType val expectedTypeRef = data.expectedType
@@ -92,7 +90,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
whenExpression = whenExpression.transformSingle(whenExhaustivenessTransformer, null) whenExpression = whenExpression.transformSingle(whenExhaustivenessTransformer, null)
dataFlowAnalyzer.exitWhenExpression(whenExpression) dataFlowAnalyzer.exitWhenExpression(whenExpression)
whenExpression = whenExpression.replaceReturnTypeIfNotExhaustive() whenExpression = whenExpression.replaceReturnTypeIfNotExhaustive()
whenExpression.compose() whenExpression
} }
} }
@@ -110,32 +108,32 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
return lastBranch.source != null && lastBranch.condition is FirElseIfTrueCondition && lastBranch.result is FirEmptyExpressionBlock return lastBranch.source != null && lastBranch.condition is FirElseIfTrueCondition && lastBranch.result is FirEmptyExpressionBlock
} }
override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): CompositeTransformResult<FirWhenBranch> { override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): FirWhenBranch {
return whenBranch.also { dataFlowAnalyzer.enterWhenBranchCondition(whenBranch) } return whenBranch.also { dataFlowAnalyzer.enterWhenBranchCondition(whenBranch) }
.transformCondition(transformer, withExpectedType(session.builtinTypes.booleanType)) .transformCondition(transformer, withExpectedType(session.builtinTypes.booleanType))
.also { dataFlowAnalyzer.exitWhenBranchCondition(it) } .also { dataFlowAnalyzer.exitWhenBranchCondition(it) }
.transformResult(transformer, data) .transformResult(transformer, data)
.also { dataFlowAnalyzer.exitWhenBranchResult(it) } .also { dataFlowAnalyzer.exitWhenBranchResult(it) }
.compose()
} }
override fun transformWhenSubjectExpression( override fun transformWhenSubjectExpression(
whenSubjectExpression: FirWhenSubjectExpression, whenSubjectExpression: FirWhenSubjectExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
val parentWhen = whenSubjectExpression.whenRef.value val parentWhen = whenSubjectExpression.whenRef.value
val subjectType = parentWhen.subject?.resultType ?: parentWhen.subjectVariable?.returnTypeRef val subjectType = parentWhen.subject?.resultType ?: parentWhen.subjectVariable?.returnTypeRef
if (subjectType != null) { if (subjectType != null) {
whenSubjectExpression.resultType = subjectType whenSubjectExpression.resultType = subjectType
} }
return whenSubjectExpression.compose() return whenSubjectExpression
} }
// ------------------------------- Try/catch expressions ------------------------------- // ------------------------------- Try/catch expressions -------------------------------
override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): FirStatement {
if (tryExpression.calleeReference is FirResolvedNamedReference && tryExpression.resultType !is FirImplicitTypeRef) { if (tryExpression.calleeReference is FirResolvedNamedReference && tryExpression.resultType !is FirImplicitTypeRef) {
return tryExpression.compose() return tryExpression
} }
tryExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent) tryExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent)
@@ -168,30 +166,30 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
result result
} }
dataFlowAnalyzer.exitTryExpression(callCompleted) dataFlowAnalyzer.exitTryExpression(callCompleted)
return result.compose() return result
} }
override fun transformCatch(catch: FirCatch, data: ResolutionMode): CompositeTransformResult<FirCatch> { override fun transformCatch(catch: FirCatch, data: ResolutionMode): FirCatch {
dataFlowAnalyzer.enterCatchClause(catch) dataFlowAnalyzer.enterCatchClause(catch)
catch.parameter.transformReturnTypeRef(transformer, ResolutionMode.ContextIndependent) catch.parameter.transformReturnTypeRef(transformer, ResolutionMode.ContextIndependent)
return context.forBlock { return context.forBlock {
catch.transformParameter(transformer, ResolutionMode.ContextIndependent) catch.transformParameter(transformer, ResolutionMode.ContextIndependent)
catch.transformBlock(transformer, ResolutionMode.ContextDependent) catch.transformBlock(transformer, ResolutionMode.ContextDependent)
}.also { dataFlowAnalyzer.exitCatchClause(it) }.compose() }.also { dataFlowAnalyzer.exitCatchClause(it) }
} }
// ------------------------------- Jumps ------------------------------- // ------------------------------- Jumps -------------------------------
override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: ResolutionMode): FirStatement {
val result = transformer.transformExpression(jump, data).single val result = transformer.transformExpression(jump, data)
dataFlowAnalyzer.exitJump(jump) dataFlowAnalyzer.exitJump(jump)
return result.compose() return result
} }
override fun transformReturnExpression( override fun transformReturnExpression(
returnExpression: FirReturnExpression, returnExpression: FirReturnExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
val labeledElement = returnExpression.target.labeledElement val labeledElement = returnExpression.target.labeledElement
val expectedTypeRef = labeledElement.returnTypeRef val expectedTypeRef = labeledElement.returnTypeRef
@Suppress("IntroduceWhenSubject") @Suppress("IntroduceWhenSubject")
@@ -210,9 +208,9 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
override fun transformThrowExpression( override fun transformThrowExpression(
throwExpression: FirThrowExpression, throwExpression: FirThrowExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return transformer.transformExpression(throwExpression, data).also { return transformer.transformExpression(throwExpression, data).also {
dataFlowAnalyzer.exitThrowExceptionNode(it.single as FirThrowExpression) dataFlowAnalyzer.exitThrowExceptionNode(it as FirThrowExpression)
} }
} }
@@ -221,8 +219,8 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
override fun transformElvisExpression( override fun transformElvisExpression(
elvisExpression: FirElvisExpression, elvisExpression: FirElvisExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
if (elvisExpression.calleeReference is FirResolvedNamedReference) return elvisExpression.compose() if (elvisExpression.calleeReference is FirResolvedNamedReference) return elvisExpression
elvisExpression.transformAnnotations(transformer, data) elvisExpression.transformAnnotations(transformer, data)
val expectedType = data.expectedType?.coneTypeSafe<ConeKotlinType>() val expectedType = data.expectedType?.coneTypeSafe<ConeKotlinType>()
@@ -242,6 +240,6 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
} }
dataFlowAnalyzer.exitElvis(elvisExpression) dataFlowAnalyzer.exitElvis(elvisExpression)
return result.compose() return result
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt
+69 -70
View File
@@ -63,7 +63,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
private fun transformDeclarationContent( private fun transformDeclarationContent(
declaration: FirDeclaration, data: ResolutionMode declaration: FirDeclaration, data: ResolutionMode
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
transformer.onBeforeDeclarationContentResolve(declaration) transformer.onBeforeDeclarationContentResolve(declaration)
transformer.replaceDeclarationResolvePhaseIfNeeded(declaration, transformerPhase) transformer.replaceDeclarationResolvePhaseIfNeeded(declaration, transformerPhase)
return transformer.transformDeclarationContent(declaration, data) return transformer.transformDeclarationContent(declaration, data)
@@ -72,8 +72,8 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
override fun transformDeclarationStatus( override fun transformDeclarationStatus(
declarationStatus: FirDeclarationStatus, declarationStatus: FirDeclarationStatus,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirDeclarationStatus> { ): FirDeclarationStatus {
return ((data as? ResolutionMode.WithStatus)?.status ?: declarationStatus).compose() return ((data as? ResolutionMode.WithStatus)?.status ?: declarationStatus)
} }
private fun prepareSignatureForBodyResolve(callableMember: FirCallableMemberDeclaration<*>) { private fun prepareSignatureForBodyResolve(callableMember: FirCallableMemberDeclaration<*>) {
@@ -100,15 +100,15 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
} }
} }
override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirDeclaration {
if (enumEntry.resolvePhase == transformerPhase) return enumEntry.compose() if (enumEntry.resolvePhase == transformerPhase) return enumEntry
transformer.replaceDeclarationResolvePhaseIfNeeded(enumEntry, transformerPhase) transformer.replaceDeclarationResolvePhaseIfNeeded(enumEntry, transformerPhase)
return context.forEnumEntry { return context.forEnumEntry {
(enumEntry.transformChildren(this, data) as FirEnumEntry).compose() (enumEntry.transformChildren(this, data) as FirEnumEntry)
} }
} }
override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirProperty> { override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
require(property !is FirSyntheticProperty) { "Synthetic properties should not be processed by body transfromers" } require(property !is FirSyntheticProperty) { "Synthetic properties should not be processed by body transfromers" }
if (property.isLocal) { if (property.isLocal) {
@@ -120,10 +120,10 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
} }
val returnTypeRef = property.returnTypeRef val returnTypeRef = property.returnTypeRef
if (returnTypeRef !is FirImplicitTypeRef && implicitTypeOnly) return property.compose() if (returnTypeRef !is FirImplicitTypeRef && implicitTypeOnly) return property
if (property.resolvePhase == transformerPhase) return property.compose() if (property.resolvePhase == transformerPhase) return property
if (property.resolvePhase == FirResolvePhase.BODY_RESOLVE || property.resolvePhase == transformerPhase) { if (property.resolvePhase == FirResolvePhase.BODY_RESOLVE || property.resolvePhase == transformerPhase) {
return property.compose() return property
} }
dataFlowAnalyzer.enterProperty(property) dataFlowAnalyzer.enterProperty(property)
@@ -151,15 +151,15 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
dataFlowAnalyzer.exitProperty(property)?.let { dataFlowAnalyzer.exitProperty(property)?.let {
property.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(it)) property.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(it))
} }
property.compose() property
} }
} }
override fun transformField(field: FirField, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformField(field: FirField, data: ResolutionMode): FirDeclaration {
val returnTypeRef = field.returnTypeRef val returnTypeRef = field.returnTypeRef
if (implicitTypeOnly) return field.compose() if (implicitTypeOnly) return field
if (field.resolvePhase == FirResolvePhase.BODY_RESOLVE || field.resolvePhase == transformerPhase) { if (field.resolvePhase == FirResolvePhase.BODY_RESOLVE || field.resolvePhase == transformerPhase) {
return field.compose() return field
} }
dataFlowAnalyzer.enterField(field) dataFlowAnalyzer.enterField(field)
return withFullBodyResolve { return withFullBodyResolve {
@@ -171,7 +171,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
} }
transformer.replaceDeclarationResolvePhaseIfNeeded(field, transformerPhase) transformer.replaceDeclarationResolvePhaseIfNeeded(field, transformerPhase)
dataFlowAnalyzer.exitField(field) dataFlowAnalyzer.exitField(field)
field.compose() field
} }
} }
@@ -236,16 +236,16 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
override fun transformWrappedDelegateExpression( override fun transformWrappedDelegateExpression(
wrappedDelegateExpression: FirWrappedDelegateExpression, wrappedDelegateExpression: FirWrappedDelegateExpression,
data: ResolutionMode, data: ResolutionMode,
): CompositeTransformResult<FirStatement> { ): FirStatement {
dataFlowAnalyzer.enterDelegateExpression() dataFlowAnalyzer.enterDelegateExpression()
try { try {
val delegateProvider = wrappedDelegateExpression.delegateProvider.transformSingle(transformer, data) val delegateProvider = wrappedDelegateExpression.delegateProvider.transformSingle(transformer, data)
when (val calleeReference = (delegateProvider as FirResolvable).calleeReference) { when (val calleeReference = (delegateProvider as FirResolvable).calleeReference) {
is FirResolvedNamedReference -> return delegateProvider.compose() is FirResolvedNamedReference -> return delegateProvider
is FirNamedReferenceWithCandidate -> { is FirNamedReferenceWithCandidate -> {
val candidate = calleeReference.candidate val candidate = calleeReference.candidate
if (!candidate.system.hasContradiction) { if (!candidate.system.hasContradiction) {
return delegateProvider.compose() return delegateProvider
} }
} }
} }
@@ -254,13 +254,13 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
return wrappedDelegateExpression.expression return wrappedDelegateExpression.expression
.transformSingle(transformer, data) .transformSingle(transformer, data)
.approximateIfIsIntegerConst() .approximateIfIsIntegerConst()
.compose()
} finally { } finally {
dataFlowAnalyzer.exitDelegateExpression() dataFlowAnalyzer.exitDelegateExpression()
} }
} }
private fun transformLocalVariable(variable: FirProperty): CompositeTransformResult<FirProperty> { private fun transformLocalVariable(variable: FirProperty): FirProperty {
assert(variable.isLocal) assert(variable.isLocal)
variable.transformDelegate(transformer, ResolutionMode.ContextDependentDelegate) variable.transformDelegate(transformer, ResolutionMode.ContextDependentDelegate)
val delegate = variable.delegate val delegate = variable.delegate
@@ -281,7 +281,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
context.storeVariable(variable) context.storeVariable(variable)
transformer.replaceDeclarationResolvePhaseIfNeeded(variable, transformerPhase) transformer.replaceDeclarationResolvePhaseIfNeeded(variable, transformerPhase)
dataFlowAnalyzer.exitLocalVariableDeclaration(variable) dataFlowAnalyzer.exitLocalVariableDeclaration(variable)
return variable.compose() return variable
} }
private fun FirProperty.transformChildrenWithoutAccessors(returnTypeRef: FirTypeRef): FirProperty { private fun FirProperty.transformChildrenWithoutAccessors(returnTypeRef: FirTypeRef): FirProperty {
@@ -349,29 +349,29 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
) )
} }
override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement {
if (regularClass.isLocal && regularClass !in context.targetedLocalClasses) { if (regularClass.isLocal && regularClass !in context.targetedLocalClasses) {
return regularClass.runAllPhasesForLocalClass(transformer, components, data).compose() return regularClass.runAllPhasesForLocalClass(transformer, components, data)
} }
doTransformTypeParameters(regularClass) doTransformTypeParameters(regularClass)
return doTransformRegularClass(regularClass, data) return doTransformRegularClass(regularClass, data)
} }
override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirDeclaration {
if (typeAlias.isLocal && typeAlias !in context.targetedLocalClasses) { if (typeAlias.isLocal && typeAlias !in context.targetedLocalClasses) {
return typeAlias.runAllPhasesForLocalClass(transformer, components, data).compose() return typeAlias.runAllPhasesForLocalClass(transformer, components, data)
} }
doTransformTypeParameters(typeAlias) doTransformTypeParameters(typeAlias)
typeAlias.transformAnnotations(transformer, data) typeAlias.transformAnnotations(transformer, data)
typeAlias.transformExpandedTypeRef(transformer, data) typeAlias.transformExpandedTypeRef(transformer, data)
return typeAlias.compose() return typeAlias
} }
private fun doTransformRegularClass( private fun doTransformRegularClass(
regularClass: FirRegularClass, regularClass: FirRegularClass,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult.Single<FirRegularClass> { ): FirRegularClass {
val notAnalyzed = regularClass.resolvePhase < transformerPhase val notAnalyzed = regularClass.resolvePhase < transformerPhase
if (notAnalyzed) { if (notAnalyzed) {
@@ -379,7 +379,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
} }
val result = context.withRegularClass(regularClass, components) { val result = context.withRegularClass(regularClass, components) {
transformDeclarationContent(regularClass, data).single as FirRegularClass transformDeclarationContent(regularClass, data) as FirRegularClass
} }
if (notAnalyzed) { if (notAnalyzed) {
@@ -391,16 +391,15 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
} }
} }
(@Suppress("UNCHECKED_CAST") return result
return result.compose())
} }
override fun transformAnonymousObject( override fun transformAnonymousObject(
anonymousObject: FirAnonymousObject, anonymousObject: FirAnonymousObject,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
if (anonymousObject !in context.targetedLocalClasses) { if (anonymousObject !in context.targetedLocalClasses) {
return anonymousObject.runAllPhasesForLocalClass(transformer, components, data).compose() return anonymousObject.runAllPhasesForLocalClass(transformer, components, data)
} }
dataFlowAnalyzer.enterClass() dataFlowAnalyzer.enterClass()
if (anonymousObject.typeRef !is FirResolvedTypeRef) { if (anonymousObject.typeRef !is FirResolvedTypeRef) {
@@ -410,7 +409,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
} }
} }
val result = context.withAnonymousObject(anonymousObject, components) { val result = context.withAnonymousObject(anonymousObject, components) {
transformDeclarationContent(anonymousObject, data).single as FirAnonymousObject transformDeclarationContent(anonymousObject, data) as FirAnonymousObject
} }
if (!implicitTypeOnly && result.controlFlowGraphReference == null) { if (!implicitTypeOnly && result.controlFlowGraphReference == null) {
val graph = dataFlowAnalyzer.exitAnonymousObject(result) val graph = dataFlowAnalyzer.exitAnonymousObject(result)
@@ -418,7 +417,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
} else { } else {
dataFlowAnalyzer.exitClass() dataFlowAnalyzer.exitClass()
} }
return result.compose() return result
} }
private fun transformAnonymousFunctionWithLambdaResolution( private fun transformAnonymousFunctionWithLambdaResolution(
@@ -426,7 +425,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
): FirAnonymousFunction { ): FirAnonymousFunction {
val expectedReturnType = val expectedReturnType =
lambdaResolution.expectedReturnTypeRef ?: anonymousFunction.returnTypeRef.takeUnless { it is FirImplicitTypeRef } lambdaResolution.expectedReturnTypeRef ?: anonymousFunction.returnTypeRef.takeUnless { it is FirImplicitTypeRef }
val result = transformFunction(anonymousFunction, withExpectedType(expectedReturnType)).single as FirAnonymousFunction val result = transformFunction(anonymousFunction, withExpectedType(expectedReturnType)) as FirAnonymousFunction
val body = result.body val body = result.body
if (result.returnTypeRef is FirImplicitTypeRef && body != null) { if (result.returnTypeRef is FirImplicitTypeRef && body != null) {
// TODO: This part seems unnecessary because for lambdas in dependent context will be completed and their type // TODO: This part seems unnecessary because for lambdas in dependent context will be completed and their type
@@ -454,13 +453,13 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
override fun transformSimpleFunction( override fun transformSimpleFunction(
simpleFunction: FirSimpleFunction, simpleFunction: FirSimpleFunction,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirSimpleFunction> { ): FirSimpleFunction {
if (simpleFunction.resolvePhase == FirResolvePhase.BODY_RESOLVE || simpleFunction.resolvePhase == transformerPhase) { if (simpleFunction.resolvePhase == FirResolvePhase.BODY_RESOLVE || simpleFunction.resolvePhase == transformerPhase) {
return simpleFunction.compose() return simpleFunction
} }
val returnTypeRef = simpleFunction.returnTypeRef val returnTypeRef = simpleFunction.returnTypeRef
if ((returnTypeRef !is FirImplicitTypeRef) && implicitTypeOnly) { if ((returnTypeRef !is FirImplicitTypeRef) && implicitTypeOnly) {
return simpleFunction.compose() return simpleFunction
} }
doTransformTypeParameters(simpleFunction) doTransformTypeParameters(simpleFunction)
@@ -484,9 +483,9 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
private fun <F : FirFunction<F>> transformFunctionWithGivenSignature( private fun <F : FirFunction<F>> transformFunctionWithGivenSignature(
function: F, function: F,
resolutionMode: ResolutionMode, resolutionMode: ResolutionMode,
): CompositeTransformResult<F> { ): F {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
val result = transformFunction(function, resolutionMode).single as F val result = transformFunction(function, resolutionMode) as F
val body = result.body val body = result.body
if (result.returnTypeRef is FirImplicitTypeRef) { if (result.returnTypeRef is FirImplicitTypeRef) {
@@ -511,13 +510,13 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
} }
} }
return result.compose() return result
} }
override fun <F : FirFunction<F>> transformFunction( override fun <F : FirFunction<F>> transformFunction(
function: FirFunction<F>, function: FirFunction<F>,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
val functionIsNotAnalyzed = transformerPhase != function.resolvePhase val functionIsNotAnalyzed = transformerPhase != function.resolvePhase
if (functionIsNotAnalyzed) { if (functionIsNotAnalyzed) {
dataFlowAnalyzer.enterFunction(function) dataFlowAnalyzer.enterFunction(function)
@@ -525,15 +524,15 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return transformDeclarationContent(function, data).also { return transformDeclarationContent(function, data).also {
if (functionIsNotAnalyzed) { if (functionIsNotAnalyzed) {
val result = it.single as FirFunction<*> val result = it as FirFunction<*>
val controlFlowGraphReference = dataFlowAnalyzer.exitFunction(result) val controlFlowGraphReference = dataFlowAnalyzer.exitFunction(result)
result.replaceControlFlowGraphReference(controlFlowGraphReference) result.replaceControlFlowGraphReference(controlFlowGraphReference)
} }
} as CompositeTransformResult<FirStatement> } as FirStatement
} }
override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration {
if (implicitTypeOnly) return constructor.compose() if (implicitTypeOnly) return constructor
val container = context.containerIfAny as? FirRegularClass val container = context.containerIfAny as? FirRegularClass
if (constructor.isPrimary && container?.classKind == ClassKind.ANNOTATION_CLASS) { if (constructor.isPrimary && container?.classKind == ClassKind.ANNOTATION_CLASS) {
return withFirArrayOfCallTransformer { return withFirArrayOfCallTransformer {
@@ -545,7 +544,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
return doTransformConstructor(constructor, data) return doTransformConstructor(constructor, data)
} }
private fun doTransformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirConstructor> { private fun doTransformConstructor(constructor: FirConstructor, data: ResolutionMode): FirConstructor {
val owningClass = context.containerIfAny as? FirRegularClass val owningClass = context.containerIfAny as? FirRegularClass
transformer.replaceDeclarationResolvePhaseIfNeeded(constructor, transformerPhase) transformer.replaceDeclarationResolvePhaseIfNeeded(constructor, transformerPhase)
@@ -568,25 +567,25 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
val controlFlowGraphReference = dataFlowAnalyzer.exitFunction(constructor) val controlFlowGraphReference = dataFlowAnalyzer.exitFunction(constructor)
constructor.replaceControlFlowGraphReference(controlFlowGraphReference) constructor.replaceControlFlowGraphReference(controlFlowGraphReference)
return constructor.compose() return constructor
} }
override fun transformAnonymousInitializer( override fun transformAnonymousInitializer(
anonymousInitializer: FirAnonymousInitializer, anonymousInitializer: FirAnonymousInitializer,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
if (implicitTypeOnly) return anonymousInitializer.compose() if (implicitTypeOnly) return anonymousInitializer
dataFlowAnalyzer.enterInitBlock(anonymousInitializer) dataFlowAnalyzer.enterInitBlock(anonymousInitializer)
return context.withAnonymousInitializer(anonymousInitializer) { return context.withAnonymousInitializer(anonymousInitializer) {
val result = val result =
transformDeclarationContent(anonymousInitializer, ResolutionMode.ContextIndependent).single as FirAnonymousInitializer transformDeclarationContent(anonymousInitializer, ResolutionMode.ContextIndependent) as FirAnonymousInitializer
val graph = dataFlowAnalyzer.exitInitBlock(result) val graph = dataFlowAnalyzer.exitInitBlock(result)
result.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(graph)) result.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(graph))
result.compose() result
} }
} }
override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement {
if (valueParameter.returnTypeRef is FirImplicitTypeRef) { if (valueParameter.returnTypeRef is FirImplicitTypeRef) {
transformer.replaceDeclarationResolvePhaseIfNeeded(valueParameter, transformerPhase) transformer.replaceDeclarationResolvePhaseIfNeeded(valueParameter, transformerPhase)
valueParameter.replaceReturnTypeRef( valueParameter.replaceReturnTypeRef(
@@ -595,7 +594,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
) )
) )
return context.withValueParameter(valueParameter) { return context.withValueParameter(valueParameter) {
valueParameter.compose() valueParameter
} }
} }
@@ -604,20 +603,20 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
transformDeclarationContent( transformDeclarationContent(
valueParameter, valueParameter,
withExpectedType(valueParameter.returnTypeRef) withExpectedType(valueParameter.returnTypeRef)
).single as FirValueParameter ) as FirValueParameter
} }
dataFlowAnalyzer.exitValueParameter(result)?.let { graph -> dataFlowAnalyzer.exitValueParameter(result)?.let { graph ->
result.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(graph)) result.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(graph))
} }
return result.compose() return result
} }
override fun transformAnonymousFunction( override fun transformAnonymousFunction(
anonymousFunction: FirAnonymousFunction, anonymousFunction: FirAnonymousFunction,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
// Either ContextDependent, ContextIndependent or WithExpectedType could be here // Either ContextDependent, ContextIndependent or WithExpectedType could be here
if (data !is ResolutionMode.LambdaResolution) { if (data !is ResolutionMode.LambdaResolution) {
anonymousFunction.transformReturnTypeRef(transformer, ResolutionMode.ContextIndependent) anonymousFunction.transformReturnTypeRef(transformer, ResolutionMode.ContextIndependent)
@@ -628,12 +627,12 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
is ResolutionMode.ContextDependent, is ResolutionMode.ContextDependentDelegate -> { is ResolutionMode.ContextDependent, is ResolutionMode.ContextDependentDelegate -> {
context.withAnonymousFunction(anonymousFunction, components, data) { context.withAnonymousFunction(anonymousFunction, components, data) {
dataFlowAnalyzer.visitPostponedAnonymousFunction(anonymousFunction) dataFlowAnalyzer.visitPostponedAnonymousFunction(anonymousFunction)
anonymousFunction.addReturn().compose() anonymousFunction.addReturn()
} }
} }
is ResolutionMode.LambdaResolution -> { is ResolutionMode.LambdaResolution -> {
context.withAnonymousFunction(anonymousFunction, components, data) { context.withAnonymousFunction(anonymousFunction, components, data) {
transformAnonymousFunctionWithLambdaResolution(anonymousFunction, data).addReturn().compose() transformAnonymousFunctionWithLambdaResolution(anonymousFunction, data).addReturn()
} }
} }
is ResolutionMode.WithExpectedType, is ResolutionMode.ContextIndependent -> { is ResolutionMode.WithExpectedType, is ResolutionMode.ContextIndependent -> {
@@ -696,7 +695,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
lambda = lambda.transformValueParameters(ImplicitToErrorTypeTransformer, null) lambda = lambda.transformValueParameters(ImplicitToErrorTypeTransformer, null)
val bodyExpectedType = returnTypeRefFromResolvedAtom ?: expectedTypeRef val bodyExpectedType = returnTypeRefFromResolvedAtom ?: expectedTypeRef
context.withAnonymousFunction(lambda, components, data) { context.withAnonymousFunction(lambda, components, data) {
lambda = transformFunction(lambda, withExpectedType(bodyExpectedType)).single as FirAnonymousFunction lambda = transformFunction(lambda, withExpectedType(bodyExpectedType)) as FirAnonymousFunction
} }
// To separate function and separate commit // To separate function and separate commit
val writer = FirCallCompletionResultsWriterTransformer( val writer = FirCallCompletionResultsWriterTransformer(
@@ -740,7 +739,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
session.lookupTracker?.recordTypeResolveAsLookup(it, lambda.source, null) session.lookupTracker?.recordTypeResolveAsLookup(it, lambda.source, null)
} }
) )
lambda.addReturn().compose() lambda.addReturn()
} }
is ResolutionMode.WithStatus -> { is ResolutionMode.WithStatus -> {
throw AssertionError("Should not be here in WithStatus mode") throw AssertionError("Should not be here in WithStatus mode")
@@ -761,7 +760,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
if (lastStatement is FirExpression && !returnNothing) { if (lastStatement is FirExpression && !returnNothing) {
body?.transformChildren( body?.transformChildren(
object : FirDefaultTransformer<FirExpression>() { object : FirDefaultTransformer<FirExpression>() {
override fun <E : FirElement> transformElement(element: E, data: FirExpression): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: FirExpression): E {
if (element == lastStatement) { if (element == lastStatement) {
val returnExpression = buildReturnExpression { val returnExpression = buildReturnExpression {
source = element.source?.fakeElement(FirFakeSourceElementKind.ImplicitReturn) source = element.source?.fakeElement(FirFakeSourceElementKind.ImplicitReturn)
@@ -771,16 +770,16 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
} }
} }
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return (returnExpression as E).compose() return (returnExpression as E)
} }
return element.compose() return element
} }
override fun transformReturnExpression( override fun transformReturnExpression(
returnExpression: FirReturnExpression, returnExpression: FirReturnExpression,
data: FirExpression data: FirExpression
): CompositeTransformResult<FirStatement> { ): FirStatement {
return returnExpression.compose() return returnExpression
} }
}, },
buildUnitExpression() buildUnitExpression()
@@ -844,11 +843,11 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
} }
private object ImplicitToErrorTypeTransformer : FirTransformer<Nothing?>() { private object ImplicitToErrorTypeTransformer : FirTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): FirStatement {
if (valueParameter.returnTypeRef is FirImplicitTypeRef) { if (valueParameter.returnTypeRef is FirImplicitTypeRef) {
valueParameter.transformReturnTypeRef( valueParameter.transformReturnTypeRef(
StoreType, StoreType,
@@ -857,7 +856,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
) )
) )
} }
return valueParameter.compose() return valueParameter
} }
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt
+62 -62
View File
@@ -49,7 +49,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
components.callResolver.initTransformer(this) components.callResolver.initTransformer(this)
} }
override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement {
if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) { if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) {
val type = buildErrorTypeRef { val type = buildErrorTypeRef {
source = expression.source source = expression.source
@@ -60,13 +60,13 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
} }
expression.resultType = type expression.resultType = type
} }
return (expression.transformChildren(transformer, data) as FirStatement).compose() return (expression.transformChildren(transformer, data) as FirStatement)
} }
override fun transformQualifiedAccessExpression( override fun transformQualifiedAccessExpression(
qualifiedAccessExpression: FirQualifiedAccessExpression, qualifiedAccessExpression: FirQualifiedAccessExpression,
data: ResolutionMode, data: ResolutionMode,
): CompositeTransformResult<FirStatement> { ): FirStatement {
qualifiedAccessExpression.transformAnnotations(this, data) qualifiedAccessExpression.transformAnnotations(this, data)
qualifiedAccessExpression.transformTypeArguments(transformer, ResolutionMode.ContextIndependent) qualifiedAccessExpression.transformTypeArguments(transformer, ResolutionMode.ContextIndependent)
@@ -119,7 +119,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
// so candidate existence must be checked before calling completion // so candidate existence must be checked before calling completion
if (transformedCallee is FirQualifiedAccessExpression && transformedCallee.candidate() != null) { if (transformedCallee is FirQualifiedAccessExpression && transformedCallee.candidate() != null) {
if (!transformedCallee.isAcceptableResolvedQualifiedAccess()) { if (!transformedCallee.isAcceptableResolvedQualifiedAccess()) {
return qualifiedAccessExpression.compose() return qualifiedAccessExpression
} }
callCompleter.completeCall(transformedCallee, data.expectedType).result callCompleter.completeCall(transformedCallee, data.expectedType).result
} else { } else {
@@ -137,7 +137,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
dataFlowAnalyzer.exitResolvedQualifierNode(result) dataFlowAnalyzer.exitResolvedQualifierNode(result)
} }
} }
return result.compose() return result
} }
fun transformSuperReceiver( fun transformSuperReceiver(
@@ -232,7 +232,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
override fun transformSafeCallExpression( override fun transformSafeCallExpression(
safeCallExpression: FirSafeCallExpression, safeCallExpression: FirSafeCallExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
safeCallExpression.transformAnnotations(this, ResolutionMode.ContextIndependent) safeCallExpression.transformAnnotations(this, ResolutionMode.ContextIndependent)
safeCallExpression.transformReceiver(this, ResolutionMode.ContextIndependent) safeCallExpression.transformReceiver(this, ResolutionMode.ContextIndependent)
@@ -248,17 +248,17 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
dataFlowAnalyzer.exitSafeCall(safeCallExpression) dataFlowAnalyzer.exitSafeCall(safeCallExpression)
return safeCallExpression.compose() return safeCallExpression
} }
override fun transformCheckedSafeCallSubject( override fun transformCheckedSafeCallSubject(
checkedSafeCallSubject: FirCheckedSafeCallSubject, checkedSafeCallSubject: FirCheckedSafeCallSubject,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return checkedSafeCallSubject.compose() return checkedSafeCallSubject
} }
override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): FirStatement {
if (functionCall.calleeReference is FirResolvedNamedReference && functionCall.resultType is FirImplicitTypeRef) { if (functionCall.calleeReference is FirResolvedNamedReference && functionCall.resultType is FirImplicitTypeRef) {
storeTypeFromCallee(functionCall) storeTypeFromCallee(functionCall)
} }
@@ -268,9 +268,9 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
if (functionCall.calleeReference !is FirResolvedNamedReference) { if (functionCall.calleeReference !is FirResolvedNamedReference) {
functionCall.transformChildren(transformer, data) functionCall.transformChildren(transformer, data)
} }
return functionCall.compose() return functionCall
} }
if (functionCall.calleeReference is FirNamedReferenceWithCandidate) return functionCall.compose() if (functionCall.calleeReference is FirNamedReferenceWithCandidate) return functionCall
dataFlowAnalyzer.enterCall() dataFlowAnalyzer.enterCall()
functionCall.transformAnnotations(transformer, data) functionCall.transformAnnotations(transformer, data)
functionCall.transformSingle(InvocationKindTransformer, null) functionCall.transformSingle(InvocationKindTransformer, null)
@@ -294,18 +294,18 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
if (callCompleted) { if (callCompleted) {
if (enableArrayOfCallTransformation) { if (enableArrayOfCallTransformation) {
arrayOfCallTransformer.toArrayOfCall(completeInference)?.let { arrayOfCallTransformer.toArrayOfCall(completeInference)?.let {
return it.compose() return it
} }
} }
} }
return completeInference.compose() return completeInference
} }
override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformBlock(block: FirBlock, data: ResolutionMode): FirStatement {
context.forBlock { context.forBlock {
transformBlockInCurrentScope(block, data) transformBlockInCurrentScope(block, data)
} }
return block.compose() return block
} }
internal fun transformBlockInCurrentScope(block: FirBlock, data: ResolutionMode) { internal fun transformBlockInCurrentScope(block: FirBlock, data: ResolutionMode) {
@@ -332,24 +332,24 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
override fun transformThisReceiverExpression( override fun transformThisReceiverExpression(
thisReceiverExpression: FirThisReceiverExpression, thisReceiverExpression: FirThisReceiverExpression,
data: ResolutionMode, data: ResolutionMode,
): CompositeTransformResult<FirStatement> { ): FirStatement {
return transformQualifiedAccessExpression(thisReceiverExpression, data) return transformQualifiedAccessExpression(thisReceiverExpression, data)
} }
override fun transformComparisonExpression( override fun transformComparisonExpression(
comparisonExpression: FirComparisonExpression, comparisonExpression: FirComparisonExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return (comparisonExpression.transformChildren(transformer, ResolutionMode.ContextIndependent) as FirComparisonExpression).also { return (comparisonExpression.transformChildren(transformer, ResolutionMode.ContextIndependent) as FirComparisonExpression).also {
it.resultType = comparisonExpression.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type) it.resultType = comparisonExpression.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type)
dataFlowAnalyzer.exitComparisonExpressionCall(it) dataFlowAnalyzer.exitComparisonExpressionCall(it)
}.compose() }
} }
override fun transformAssignmentOperatorStatement( override fun transformAssignmentOperatorStatement(
assignmentOperatorStatement: FirAssignmentOperatorStatement, assignmentOperatorStatement: FirAssignmentOperatorStatement,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
require(assignmentOperatorStatement.operation != FirOperation.ASSIGN) require(assignmentOperatorStatement.operation != FirOperation.ASSIGN)
assignmentOperatorStatement.transformAnnotations(transformer, ResolutionMode.ContextIndependent) assignmentOperatorStatement.transformAnnotations(transformer, ResolutionMode.ContextIndependent)
@@ -392,7 +392,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
operatorIsError || (!lhsIsVar && !assignIsError) -> { operatorIsError || (!lhsIsVar && !assignIsError) -> {
callCompleter.completeCall(resolvedAssignCall, noExpectedType) callCompleter.completeCall(resolvedAssignCall, noExpectedType)
dataFlowAnalyzer.exitFunctionCall(resolvedAssignCall, callCompleted = true) dataFlowAnalyzer.exitFunctionCall(resolvedAssignCall, callCompleted = true)
resolvedAssignCall.compose() resolvedAssignCall
} }
assignIsError -> { assignIsError -> {
callCompleter.completeCall(resolvedOperatorCall, lhsVariable?.returnTypeRef ?: noExpectedType) callCompleter.completeCall(resolvedOperatorCall, lhsVariable?.returnTypeRef ?: noExpectedType)
@@ -430,7 +430,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
buildErrorExpression { buildErrorExpression {
source = assignmentOperatorStatement.source source = assignmentOperatorStatement.source
diagnostic = ConeOperatorAmbiguityError(listOf(operatorCallSymbol, assignmentCallSymbol)) diagnostic = ConeOperatorAmbiguityError(listOf(operatorCallSymbol, assignmentCallSymbol))
}.compose() }
} }
} }
} }
@@ -438,11 +438,11 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
override fun transformEqualityOperatorCall( override fun transformEqualityOperatorCall(
equalityOperatorCall: FirEqualityOperatorCall, equalityOperatorCall: FirEqualityOperatorCall,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
val result = (equalityOperatorCall.transformChildren(transformer, ResolutionMode.ContextIndependent) as FirEqualityOperatorCall) val result = (equalityOperatorCall.transformChildren(transformer, ResolutionMode.ContextIndependent) as FirEqualityOperatorCall)
.also { it.resultType = equalityOperatorCall.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type) } .also { it.resultType = equalityOperatorCall.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type) }
dataFlowAnalyzer.exitEqualityOperatorCall(result) dataFlowAnalyzer.exitEqualityOperatorCall(result)
return result.compose() return result
} }
private inline fun <T> resolveCandidateForAssignmentOperatorCall(block: () -> T): T { private inline fun <T> resolveCandidateForAssignmentOperatorCall(block: () -> T): T {
@@ -540,22 +540,22 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
override fun transformTypeOperatorCall( override fun transformTypeOperatorCall(
typeOperatorCall: FirTypeOperatorCall, typeOperatorCall: FirTypeOperatorCall,
data: ResolutionMode, data: ResolutionMode,
): CompositeTransformResult<FirStatement> { ): FirStatement {
val resolved = components.typeResolverTransformer.withAllowedBareTypes { val resolved = components.typeResolverTransformer.withAllowedBareTypes {
typeOperatorCall.transformConversionTypeRef(transformer, ResolutionMode.ContextIndependent) typeOperatorCall.transformConversionTypeRef(transformer, ResolutionMode.ContextIndependent)
}.transformOtherChildren(transformer, ResolutionMode.ContextIndependent) }.transformOtherChildren(transformer, ResolutionMode.ContextIndependent)
val conversionTypeRef = resolved.conversionTypeRef.withTypeArgumentsForBareType(resolved.argument) val conversionTypeRef = resolved.conversionTypeRef.withTypeArgumentsForBareType(resolved.argument)
resolved.transformChildren(object : FirDefaultTransformer<Nothing?>() { resolved.transformChildren(object : FirDefaultTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> { override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): FirTypeRef {
return if (typeRef === resolved.conversionTypeRef) { return if (typeRef === resolved.conversionTypeRef) {
conversionTypeRef.compose() conversionTypeRef
} else { } else {
typeRef.compose() typeRef
} }
} }
}, null) }, null)
@@ -582,19 +582,19 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
else -> error("Unknown type operator: ${resolved.operation}") else -> error("Unknown type operator: ${resolved.operation}")
} }
dataFlowAnalyzer.exitTypeOperatorCall(resolved) dataFlowAnalyzer.exitTypeOperatorCall(resolved)
return resolved.compose() return resolved
} }
override fun transformCheckNotNullCall( override fun transformCheckNotNullCall(
checkNotNullCall: FirCheckNotNullCall, checkNotNullCall: FirCheckNotNullCall,
data: ResolutionMode, data: ResolutionMode,
): CompositeTransformResult<FirStatement> { ): FirStatement {
// Resolve the return type of a call to the synthetic function with signature: // Resolve the return type of a call to the synthetic function with signature:
// fun <K> checkNotNull(arg: K?): K // fun <K> checkNotNull(arg: K?): K
// ...in order to get the not-nullable type of the argument. // ...in order to get the not-nullable type of the argument.
if (checkNotNullCall.calleeReference is FirResolvedNamedReference && checkNotNullCall.resultType !is FirImplicitTypeRef) { if (checkNotNullCall.calleeReference is FirResolvedNamedReference && checkNotNullCall.resultType !is FirImplicitTypeRef) {
return checkNotNullCall.compose() return checkNotNullCall
} }
checkNotNullCall.argumentList.transformArguments(transformer, ResolutionMode.ContextDependent) checkNotNullCall.argumentList.transformArguments(transformer, ResolutionMode.ContextDependent)
@@ -613,13 +613,13 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
checkNotNullCall checkNotNullCall
} }
dataFlowAnalyzer.exitCheckNotNullCall(result, callCompleted) dataFlowAnalyzer.exitCheckNotNullCall(result, callCompleted)
return result.compose() return result
} }
override fun transformBinaryLogicExpression( override fun transformBinaryLogicExpression(
binaryLogicExpression: FirBinaryLogicExpression, binaryLogicExpression: FirBinaryLogicExpression,
data: ResolutionMode, data: ResolutionMode,
): CompositeTransformResult<FirStatement> { ): FirStatement {
val booleanType = binaryLogicExpression.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type) val booleanType = binaryLogicExpression.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type)
return when (binaryLogicExpression.kind) { return when (binaryLogicExpression.kind) {
LogicOperationKind.AND -> LogicOperationKind.AND ->
@@ -635,13 +635,13 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
.transformRightOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitBinaryOr) .transformRightOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitBinaryOr)
}.transformOtherChildren(transformer, ResolutionMode.WithExpectedType(booleanType)).also { }.transformOtherChildren(transformer, ResolutionMode.WithExpectedType(booleanType)).also {
it.resultType = booleanType it.resultType = booleanType
}.compose() }
} }
override fun transformVariableAssignment( override fun transformVariableAssignment(
variableAssignment: FirVariableAssignment, variableAssignment: FirVariableAssignment,
data: ResolutionMode, data: ResolutionMode,
): CompositeTransformResult<FirStatement> { ): FirStatement {
// val resolvedAssignment = transformCallee(variableAssignment) // val resolvedAssignment = transformCallee(variableAssignment)
variableAssignment.transformAnnotations(transformer, ResolutionMode.ContextIndependent) variableAssignment.transformAnnotations(transformer, ResolutionMode.ContextIndependent)
val resolvedAssignment = callResolver.resolveVariableAccessAndSelectCandidate(variableAssignment) val resolvedAssignment = callResolver.resolveVariableAccessAndSelectCandidate(variableAssignment)
@@ -654,15 +654,15 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
resolvedAssignment resolvedAssignment
} }
(result as? FirVariableAssignment)?.let { dataFlowAnalyzer.exitVariableAssignment(it) } (result as? FirVariableAssignment)?.let { dataFlowAnalyzer.exitVariableAssignment(it) }
return result.compose() return result
} }
override fun transformCallableReferenceAccess( override fun transformCallableReferenceAccess(
callableReferenceAccess: FirCallableReferenceAccess, callableReferenceAccess: FirCallableReferenceAccess,
data: ResolutionMode, data: ResolutionMode,
): CompositeTransformResult<FirStatement> { ): FirStatement {
if (callableReferenceAccess.calleeReference is FirResolvedNamedReference) { if (callableReferenceAccess.calleeReference is FirResolvedNamedReference) {
return callableReferenceAccess.compose() return callableReferenceAccess
} }
callableReferenceAccess.transformAnnotations(transformer, data) callableReferenceAccess.transformAnnotations(transformer, data)
@@ -686,23 +686,23 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
) ?: callableReferenceAccess ) ?: callableReferenceAccess
dataFlowAnalyzer.exitCallableReference(resolvedReference) dataFlowAnalyzer.exitCallableReference(resolvedReference)
return resolvedReference.compose() return resolvedReference
} }
context.storeCallableReferenceContext(callableReferenceAccess) context.storeCallableReferenceContext(callableReferenceAccess)
dataFlowAnalyzer.exitCallableReference(callableReferenceAccessWithTransformedLHS) dataFlowAnalyzer.exitCallableReference(callableReferenceAccessWithTransformedLHS)
return callableReferenceAccessWithTransformedLHS.compose() return callableReferenceAccessWithTransformedLHS
} }
override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): FirStatement {
val arg = getClassCall.argument val arg = getClassCall.argument
val dataWithExpectedType = if (arg is FirConstExpression<*>) { val dataWithExpectedType = if (arg is FirConstExpression<*>) {
withExpectedType(arg.typeRef.resolvedTypeFromPrototype(arg.kind.expectedConeType(session))) withExpectedType(arg.typeRef.resolvedTypeFromPrototype(arg.kind.expectedConeType(session)))
} else { } else {
data data
} }
val transformedGetClassCall = transformExpression(getClassCall, dataWithExpectedType).single as FirGetClassCall val transformedGetClassCall = transformExpression(getClassCall, dataWithExpectedType) as FirGetClassCall
val typeOfExpression = when (val lhs = transformedGetClassCall.argument) { val typeOfExpression = when (val lhs = transformedGetClassCall.argument) {
is FirResolvedQualifier -> { is FirResolvedQualifier -> {
@@ -742,13 +742,13 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
buildResolvedTypeRef { buildResolvedTypeRef {
type = StandardClassIds.KClass.constructClassLikeType(arrayOf(typeOfExpression), false) type = StandardClassIds.KClass.constructClassLikeType(arrayOf(typeOfExpression), false)
} }
return transformedGetClassCall.compose() return transformedGetClassCall
} }
override fun <T> transformConstExpression( override fun <T> transformConstExpression(
constExpression: FirConstExpression<T>, constExpression: FirConstExpression<T>,
data: ResolutionMode, data: ResolutionMode,
): CompositeTransformResult<FirStatement> { ): FirStatement {
constExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent) constExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent)
val type = when (val kind = constExpression.kind) { val type = when (val kind = constExpression.kind) {
@@ -770,27 +770,27 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
dataFlowAnalyzer.exitConstExpression(constExpression as FirConstExpression<*>) dataFlowAnalyzer.exitConstExpression(constExpression as FirConstExpression<*>)
constExpression.resultType = constExpression.resultType.resolvedTypeFromPrototype(type) constExpression.resultType = constExpression.resultType.resolvedTypeFromPrototype(type)
return constExpression.compose() return constExpression
} }
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement {
if (annotationCall.resolveStatus == FirAnnotationResolveStatus.Resolved) return annotationCall.compose() if (annotationCall.resolveStatus == FirAnnotationResolveStatus.Resolved) return annotationCall
return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.Resolved) return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.Resolved)
} }
protected fun resolveAnnotationCall( protected fun resolveAnnotationCall(
annotationCall: FirAnnotationCall, annotationCall: FirAnnotationCall,
status: FirAnnotationResolveStatus status: FirAnnotationResolveStatus
): CompositeTransformResult<FirAnnotationCall> { ): FirAnnotationCall {
dataFlowAnalyzer.enterAnnotationCall(annotationCall) dataFlowAnalyzer.enterAnnotationCall(annotationCall)
return withFirArrayOfCallTransformer { return withFirArrayOfCallTransformer {
annotationCall.transformAnnotationTypeRef(transformer, ResolutionMode.ContextIndependent) annotationCall.transformAnnotationTypeRef(transformer, ResolutionMode.ContextIndependent)
if (status == FirAnnotationResolveStatus.PartiallyResolved) return annotationCall.compose() if (status == FirAnnotationResolveStatus.PartiallyResolved) return annotationCall
val result = callResolver.resolveAnnotationCall(annotationCall) ?: return annotationCall.compose() val result = callResolver.resolveAnnotationCall(annotationCall) ?: return annotationCall
callCompleter.completeCall(result, noExpectedType) callCompleter.completeCall(result, noExpectedType)
result.replaceResolveStatus(status) result.replaceResolveStatus(status)
dataFlowAnalyzer.exitAnnotationCall(result) dataFlowAnalyzer.exitAnnotationCall(result)
annotationCall.compose() annotationCall
} }
} }
@@ -806,10 +806,10 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
override fun transformDelegatedConstructorCall( override fun transformDelegatedConstructorCall(
delegatedConstructorCall: FirDelegatedConstructorCall, delegatedConstructorCall: FirDelegatedConstructorCall,
data: ResolutionMode, data: ResolutionMode,
): CompositeTransformResult<FirStatement> { ): FirStatement {
if (transformer.implicitTypeOnly) return delegatedConstructorCall.compose() if (transformer.implicitTypeOnly) return delegatedConstructorCall
when (delegatedConstructorCall.calleeReference) { when (delegatedConstructorCall.calleeReference) {
is FirResolvedNamedReference, is FirErrorNamedReference -> return delegatedConstructorCall.compose() is FirResolvedNamedReference, is FirErrorNamedReference -> return delegatedConstructorCall
} }
val containers = components.context.containers val containers = components.context.containers
val containingClass = containers[containers.lastIndex - 1] as FirClass<*> val containingClass = containers[containers.lastIndex - 1] as FirClass<*>
@@ -839,15 +839,15 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
val reference = delegatedConstructorCall.calleeReference val reference = delegatedConstructorCall.calleeReference
val constructorType: ConeClassLikeType = when (reference) { val constructorType: ConeClassLikeType = when (reference) {
is FirThisReference -> { is FirThisReference -> {
lastDispatchReceiver?.type as? ConeClassLikeType ?: return delegatedConstructorCall.compose() lastDispatchReceiver?.type as? ConeClassLikeType ?: return delegatedConstructorCall
} }
is FirSuperReference -> { is FirSuperReference -> {
// TODO: unresolved supertype // TODO: unresolved supertype
val supertype = reference.superTypeRef.coneTypeSafe<ConeClassLikeType>() val supertype = reference.superTypeRef.coneTypeSafe<ConeClassLikeType>()
?.takeIf { it !is ConeClassErrorType } ?: return delegatedConstructorCall.compose() ?.takeIf { it !is ConeClassErrorType } ?: return delegatedConstructorCall
supertype.fullyExpandedType(session) supertype.fullyExpandedType(session)
} }
else -> return delegatedConstructorCall.compose() else -> return delegatedConstructorCall
} }
val resolvedCall = callResolver.resolveDelegatingConstructorCall(delegatedConstructorCall, constructorType) val resolvedCall = callResolver.resolveDelegatingConstructorCall(delegatedConstructorCall, constructorType)
@@ -862,7 +862,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
val completionResult = callCompleter.completeCall(resolvedCall, noExpectedType) val completionResult = callCompleter.completeCall(resolvedCall, noExpectedType)
result = completionResult.result result = completionResult.result
callCompleted = completionResult.callCompleted callCompleted = completionResult.callCompleted
return result.compose() return result
} finally { } finally {
dataFlowAnalyzer.exitDelegatedConstructorCall(result, callCompleted) dataFlowAnalyzer.exitDelegatedConstructorCall(result, callCompleted)
} }
@@ -881,7 +881,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
override fun transformAugmentedArraySetCall( override fun transformAugmentedArraySetCall(
augmentedArraySetCall: FirAugmentedArraySetCall, augmentedArraySetCall: FirAugmentedArraySetCall,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
assert(augmentedArraySetCall.operation in FirOperation.ASSIGNMENTS) assert(augmentedArraySetCall.operation in FirOperation.ASSIGNMENTS)
assert(augmentedArraySetCall.operation != FirOperation.ASSIGN) assert(augmentedArraySetCall.operation != FirOperation.ASSIGN)
@@ -936,7 +936,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
} }
} }
} }
return result.compose() return result
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt
+14 -16
View File
@@ -21,9 +21,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.utils.addToStdlib.runIf import org.jetbrains.kotlin.utils.addToStdlib.runIf
@OptIn(AdapterForResolveProcessor::class) @OptIn(AdapterForResolveProcessor::class)
@@ -47,11 +45,11 @@ class FirImplicitTypeBodyResolveTransformerAdapter(session: FirSession, scopeSes
returnTypeCalculator returnTypeCalculator
) )
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> { override fun transformFile(file: FirFile, data: Nothing?): FirFile {
return file.transform(transformer, ResolutionMode.ContextIndependent) return file.transform(transformer, ResolutionMode.ContextIndependent)
} }
} }
@@ -94,7 +92,7 @@ fun <F : FirClassLikeDeclaration<F>> F.runContractAndBodiesResolutionForLocalCla
val members = localClassesNavigationInfo.allMembers val members = localClassesNavigationInfo.allMembers
graphBuilder.prepareForLocalClassMembers(members) graphBuilder.prepareForLocalClassMembers(members)
return this.transform<F, ResolutionMode>(transformer, resolutionMode).single.also { return this.transform<F, ResolutionMode>(transformer, resolutionMode).also {
graphBuilder.cleanAfterForLocalClassMembers(members) graphBuilder.cleanAfterForLocalClassMembers(members)
} }
} }
@@ -138,13 +136,13 @@ open class FirImplicitAwareBodyResolveTransformer(
override fun transformSimpleFunction( override fun transformSimpleFunction(
simpleFunction: FirSimpleFunction, simpleFunction: FirSimpleFunction,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirSimpleFunction> { ): FirSimpleFunction {
return computeCachedTransformationResult(simpleFunction) { return computeCachedTransformationResult(simpleFunction) {
super.transformSimpleFunction(simpleFunction, data) super.transformSimpleFunction(simpleFunction, data)
} }
} }
override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirProperty> { override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
return computeCachedTransformationResult(property) { return computeCachedTransformationResult(property) {
super.transformProperty(property, data) super.transformProperty(property, data)
} }
@@ -152,18 +150,18 @@ open class FirImplicitAwareBodyResolveTransformer(
private fun <D : FirCallableMemberDeclaration<D>> computeCachedTransformationResult( private fun <D : FirCallableMemberDeclaration<D>> computeCachedTransformationResult(
member: D, member: D,
transform: () -> CompositeTransformResult<D> transform: () -> D
): CompositeTransformResult<D> { ): D {
if (!implicitTypeOnly && member.returnTypeRef is FirResolvedTypeRef) { if (!implicitTypeOnly && member.returnTypeRef is FirResolvedTypeRef) {
return transform() return transform()
} }
if (member.returnTypeRef is FirResolvedTypeRef) return member.compose() if (member.returnTypeRef is FirResolvedTypeRef) return member
val symbol = member.symbol val symbol = member.symbol
val status = implicitBodyResolveComputationSession.getStatus(symbol) val status = implicitBodyResolveComputationSession.getStatus(symbol)
if (status is ImplicitBodyResolveComputationStatus.Computed) { if (status is ImplicitBodyResolveComputationStatus.Computed) {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return status.transformedDeclaration.compose() as CompositeTransformResult<D> return status.transformedDeclaration as D
} }
// If somebody has started resolution recursively (from ReturnTypeCalculator), one has to track it's not being computed already // If somebody has started resolution recursively (from ReturnTypeCalculator), one has to track it's not being computed already
@@ -173,7 +171,7 @@ open class FirImplicitAwareBodyResolveTransformer(
implicitBodyResolveComputationSession.startComputing(symbol) implicitBodyResolveComputationSession.startComputing(symbol)
val result = transform() val result = transform()
implicitBodyResolveComputationSession.storeResult(symbol, result.single) implicitBodyResolveComputationSession.storeResult(symbol, result)
return result return result
} }
@@ -303,13 +301,13 @@ open class FirDesignatedBodyResolveTransformerForReturnTypeCalculator(
) { ) {
var lastResult: FirElement? = null var lastResult: FirElement? = null
override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration {
if (designation.hasNext()) { if (designation.hasNext()) {
val result = designation.next().transform<FirDeclaration, ResolutionMode>(this, data).single val result = designation.next().transform<FirDeclaration, ResolutionMode>(this, data)
if (!designation.hasNext() && lastResult == null) { if (!designation.hasNext() && lastResult == null) {
lastResult = result lastResult = result
} }
return declaration.compose() return declaration
} }
return super.transformDeclarationContent(declaration, data) return super.transformDeclarationContent(declaration, data)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt
+1 -2
View File
@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.PrivateForInline import org.jetbrains.kotlin.fir.PrivateForInline
import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
abstract class FirPartialBodyResolveTransformer( abstract class FirPartialBodyResolveTransformer(
val transformer: FirBodyResolveTransformer val transformer: FirBodyResolveTransformer
@@ -33,7 +32,7 @@ abstract class FirPartialBodyResolveTransformer(
transformer.implicitTypeOnly = value transformer.implicitTypeOnly = value
} }
override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): E {
return element.transform(transformer, data) return element.transform(transformer, data)
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt
+33 -33
View File
@@ -43,18 +43,18 @@ open class FirContractResolveTransformer(
) { ) {
override val declarationsTransformer: FirDeclarationsResolveTransformer = FirDeclarationsContractResolveTransformer(this) override val declarationsTransformer: FirDeclarationsResolveTransformer = FirDeclarationsContractResolveTransformer(this)
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement {
return annotationCall.compose() return annotationCall
} }
private class FirDeclarationsContractResolveTransformer(transformer: FirBodyResolveTransformer) : FirDeclarationsResolveTransformer(transformer) { private class FirDeclarationsContractResolveTransformer(transformer: FirBodyResolveTransformer) : FirDeclarationsResolveTransformer(transformer) {
override fun transformSimpleFunction( override fun transformSimpleFunction(
simpleFunction: FirSimpleFunction, simpleFunction: FirSimpleFunction,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirSimpleFunction> { ): FirSimpleFunction {
simpleFunction.updatePhase() simpleFunction.updatePhase()
if (!simpleFunction.hasContractToResolve) { if (!simpleFunction.hasContractToResolve) {
return simpleFunction.compose() return simpleFunction
} }
val containingDeclaration = context.containerIfAny val containingDeclaration = context.containerIfAny
if (containingDeclaration != null && containingDeclaration !is FirClass<*>) { if (containingDeclaration != null && containingDeclaration !is FirClass<*>) {
@@ -63,7 +63,7 @@ open class FirContractResolveTransformer(
ConeContractDescriptionError("Local function can not be used in contract description") ConeContractDescriptionError("Local function can not be used in contract description")
) )
) )
return simpleFunction.compose() return simpleFunction
} }
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return context.withSimpleFunction(simpleFunction) { return context.withSimpleFunction(simpleFunction) {
@@ -73,37 +73,37 @@ open class FirContractResolveTransformer(
} }
} }
override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirProperty> { override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
property.updatePhase() property.updatePhase()
if ( if (
property.getter?.hasContractToResolve != true && property.setter?.hasContractToResolve != true || property.getter?.hasContractToResolve != true && property.setter?.hasContractToResolve != true ||
property.isLocal || property.delegate != null property.isLocal || property.delegate != null
) { ) {
return property.compose() return property
} }
if (property is FirSyntheticProperty) { if (property is FirSyntheticProperty) {
transformSimpleFunction(property.getter.delegate, data) transformSimpleFunction(property.getter.delegate, data)
return property.compose() return property
} }
context.withProperty(property) { context.withProperty(property) {
property.getter?.let { transformPropertyAccessor(it, property) } property.getter?.let { transformPropertyAccessor(it, property) }
property.setter?.let { transformPropertyAccessor(it, property) } property.setter?.let { transformPropertyAccessor(it, property) }
} }
return property.compose() return property
} }
override fun transformField(field: FirField, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformField(field: FirField, data: ResolutionMode): FirDeclaration {
field.updatePhase() field.updatePhase()
return field.compose() return field
} }
private fun transformPropertyAccessor( private fun transformPropertyAccessor(
propertyAccessor: FirPropertyAccessor, propertyAccessor: FirPropertyAccessor,
owner: FirProperty owner: FirProperty
): CompositeTransformResult<FirStatement> { ): FirStatement {
propertyAccessor.updatePhase() propertyAccessor.updatePhase()
if (!propertyAccessor.hasContractToResolve) { if (!propertyAccessor.hasContractToResolve) {
return propertyAccessor.compose() return propertyAccessor
} }
return context.withPropertyAccessor(owner, propertyAccessor, components, forContracts = true) { return context.withPropertyAccessor(owner, propertyAccessor, components, forContracts = true) {
transformContractDescriptionOwner(propertyAccessor) transformContractDescriptionOwner(propertyAccessor)
@@ -112,7 +112,7 @@ open class FirContractResolveTransformer(
private fun <T : FirContractDescriptionOwner> transformContractDescriptionOwner( private fun <T : FirContractDescriptionOwner> transformContractDescriptionOwner(
owner: T owner: T
): CompositeTransformResult<T> { ): T {
dataFlowAnalyzer.enterContractDescription() dataFlowAnalyzer.enterContractDescription()
return when (val contractDescription = owner.contractDescription) { return when (val contractDescription = owner.contractDescription) {
is FirLegacyRawContractDescription -> transformLegacyRawContractDescriptionOwner(owner, contractDescription) is FirLegacyRawContractDescription -> transformLegacyRawContractDescriptionOwner(owner, contractDescription)
@@ -124,7 +124,7 @@ open class FirContractResolveTransformer(
private fun <T : FirContractDescriptionOwner> transformLegacyRawContractDescriptionOwner( private fun <T : FirContractDescriptionOwner> transformLegacyRawContractDescriptionOwner(
owner: T, owner: T,
contractDescription: FirLegacyRawContractDescription contractDescription: FirLegacyRawContractDescription
): CompositeTransformResult<T> { ): T {
val valueParameters = owner.valueParameters val valueParameters = owner.valueParameters
for (valueParameter in valueParameters) { for (valueParameter in valueParameters) {
context.storeVariable(valueParameter) context.storeVariable(valueParameter)
@@ -150,13 +150,13 @@ open class FirContractResolveTransformer(
} }
owner.replaceContractDescription(resolvedContractDescription) owner.replaceContractDescription(resolvedContractDescription)
dataFlowAnalyzer.exitContractDescription() dataFlowAnalyzer.exitContractDescription()
return owner.compose() return owner
} }
private fun <T : FirContractDescriptionOwner> transformRawContractDescriptionOwner( private fun <T : FirContractDescriptionOwner> transformRawContractDescriptionOwner(
owner: T, owner: T,
contractDescription: FirRawContractDescription contractDescription: FirRawContractDescription
): CompositeTransformResult<T> { ): T {
val effectsBlock = buildAnonymousFunction { val effectsBlock = buildAnonymousFunction {
session = this@FirDeclarationsContractResolveTransformer.session session = this@FirDeclarationsContractResolveTransformer.session
origin = FirDeclarationOrigin.Source origin = FirDeclarationOrigin.Source
@@ -194,64 +194,64 @@ open class FirContractResolveTransformer(
return transformLegacyRawContractDescriptionOwner(owner, legacyRawContractDescription) return transformLegacyRawContractDescriptionOwner(owner, legacyRawContractDescription)
} }
private fun <T : FirContractDescriptionOwner> transformOwnerWithUnresolvedContract(owner: T): CompositeTransformResult<T> { private fun <T : FirContractDescriptionOwner> transformOwnerWithUnresolvedContract(owner: T): T {
return when (val contractDescription = owner.contractDescription) { return when (val contractDescription = owner.contractDescription) {
is FirLegacyRawContractDescription -> { // old syntax contract description is FirLegacyRawContractDescription -> { // old syntax contract description
val functionCall = contractDescription.contractCall val functionCall = contractDescription.contractCall
owner.replaceContractDescription(FirEmptyContractDescription) owner.replaceContractDescription(FirEmptyContractDescription)
owner.body.replaceFirstStatement(functionCall) owner.body.replaceFirstStatement(functionCall)
dataFlowAnalyzer.exitContractDescription() dataFlowAnalyzer.exitContractDescription()
owner.compose() owner
} }
is FirRawContractDescription -> { // new syntax contract description is FirRawContractDescription -> { // new syntax contract description
owner.replaceContractDescription(FirEmptyContractDescription) owner.replaceContractDescription(FirEmptyContractDescription)
dataFlowAnalyzer.exitContractDescription() dataFlowAnalyzer.exitContractDescription()
owner.compose() owner
} }
else -> owner.compose() // TODO: change else -> owner // TODO: change
} }
} }
override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement {
regularClass.updatePhase() regularClass.updatePhase()
regularClass.transformCompanionObject(this, data) regularClass.transformCompanionObject(this, data)
context.withRegularClass(regularClass, components, forContracts = true) { context.withRegularClass(regularClass, components, forContracts = true) {
regularClass.transformDeclarations(this, data) regularClass.transformDeclarations(this, data)
} }
return regularClass.compose() return regularClass
} }
override fun transformAnonymousObject( override fun transformAnonymousObject(
anonymousObject: FirAnonymousObject, anonymousObject: FirAnonymousObject,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
anonymousObject.updatePhase() anonymousObject.updatePhase()
context.withAnonymousObject(anonymousObject, components) { context.withAnonymousObject(anonymousObject, components) {
anonymousObject.transformDeclarations(this, data) anonymousObject.transformDeclarations(this, data)
} }
return anonymousObject.compose() return anonymousObject
} }
override fun transformAnonymousInitializer( override fun transformAnonymousInitializer(
anonymousInitializer: FirAnonymousInitializer, anonymousInitializer: FirAnonymousInitializer,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
return anonymousInitializer.compose() return anonymousInitializer
} }
override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration {
constructor.updatePhase() constructor.updatePhase()
return constructor.compose() return constructor
} }
override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirDeclaration {
return enumEntry.compose() return enumEntry
} }
private fun <T : FirContractDescriptionOwner> transformOwnerOfErrorContract(owner: T): CompositeTransformResult<T> { private fun <T : FirContractDescriptionOwner> transformOwnerOfErrorContract(owner: T): T {
// TODO // TODO
dataFlowAnalyzer.exitContractDescription() dataFlowAnalyzer.exitContractDescription()
return owner.compose() return owner
} }
private val FirContractDescriptionOwner.hasContractToResolve: Boolean private val FirContractDescriptionOwner.hasContractToResolve: Boolean
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt
+3 -7
View File
@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers.contracts
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirFile
@@ -17,10 +16,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor
import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorForFullBodyResolve import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorForFullBodyResolve
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.fir.visitors.transformSingle
@OptIn(AdapterForResolveProcessor::class) @OptIn(AdapterForResolveProcessor::class)
@@ -31,11 +27,11 @@ class FirContractResolveProcessor(session: FirSession, scopeSession: ScopeSessio
@AdapterForResolveProcessor @AdapterForResolveProcessor
class FirContractResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Nothing?>() { class FirContractResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Nothing?>() {
private val transformer = FirContractResolveTransformer(session, scopeSession) private val transformer = FirContractResolveTransformer(session, scopeSession)
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
return file.transform(transformer, ResolutionMode.ContextIndependent) return file.transform(transformer, ResolutionMode.ContextIndependent)
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt
+18 -20
View File
@@ -16,19 +16,17 @@ import org.jetbrains.kotlin.fir.scopes.FirCompositeScope
import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.scopes.createImportingScopes import org.jetbrains.kotlin.fir.scopes.createImportingScopes
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
import org.jetbrains.kotlin.fir.visitors.compose
internal abstract class FirAbstractAnnotationResolveTransformer<D, S>( internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
protected val session: FirSession, protected val session: FirSession,
protected val scopeSession: ScopeSession protected val scopeSession: ScopeSession
) : FirDefaultTransformer<D>() { ) : FirDefaultTransformer<D>() {
abstract override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult<FirStatement> abstract override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement
protected lateinit var scope: FirScope protected lateinit var scope: FirScope
override fun transformFile(file: FirFile, data: D): CompositeTransformResult<FirDeclaration> { override fun transformFile(file: FirFile, data: D): FirDeclaration {
scope = FirCompositeScope(createImportingScopes(file, session, scopeSession, useCaching = false)) scope = FirCompositeScope(createImportingScopes(file, session, scopeSession, useCaching = false))
val state = beforeChildren(file) val state = beforeChildren(file)
file.transformDeclarations(this, data) file.transformDeclarations(this, data)
@@ -36,14 +34,14 @@ internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
return transformAnnotatedDeclaration(file, data) return transformAnnotatedDeclaration(file, data)
} }
override fun transformProperty(property: FirProperty, data: D): CompositeTransformResult<FirDeclaration> { override fun transformProperty(property: FirProperty, data: D): FirDeclaration {
return transformAnnotatedDeclaration(property, data) return transformAnnotatedDeclaration(property, data)
} }
override fun transformRegularClass( override fun transformRegularClass(
regularClass: FirRegularClass, regularClass: FirRegularClass,
data: D data: D
): CompositeTransformResult<FirStatement> { ): FirStatement {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return transformAnnotatedDeclaration(regularClass, data).also { return transformAnnotatedDeclaration(regularClass, data).also {
val state = beforeChildren(regularClass) val state = beforeChildren(regularClass)
@@ -51,13 +49,13 @@ internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
regularClass.transformCompanionObject(this, data) regularClass.transformCompanionObject(this, data)
regularClass.transformSuperTypeRefs(this, data) regularClass.transformSuperTypeRefs(this, data)
afterChildren(state) afterChildren(state)
} as CompositeTransformResult<FirStatement> } as FirStatement
} }
override fun transformSimpleFunction( override fun transformSimpleFunction(
simpleFunction: FirSimpleFunction, simpleFunction: FirSimpleFunction,
data: D data: D
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
return transformAnnotatedDeclaration(simpleFunction, data).also { return transformAnnotatedDeclaration(simpleFunction, data).also {
val state = beforeChildren(simpleFunction) val state = beforeChildren(simpleFunction)
simpleFunction.transformValueParameters(this, data) simpleFunction.transformValueParameters(this, data)
@@ -68,7 +66,7 @@ internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
override fun transformConstructor( override fun transformConstructor(
constructor: FirConstructor, constructor: FirConstructor,
data: D data: D
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
return transformAnnotatedDeclaration(constructor, data).also { return transformAnnotatedDeclaration(constructor, data).also {
val state = beforeChildren(constructor) val state = beforeChildren(constructor)
constructor.transformValueParameters(this, data) constructor.transformValueParameters(this, data)
@@ -79,37 +77,37 @@ internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
override fun transformValueParameter( override fun transformValueParameter(
valueParameter: FirValueParameter, valueParameter: FirValueParameter,
data: D data: D
): CompositeTransformResult<FirStatement> { ): FirStatement {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return transformAnnotatedDeclaration(valueParameter, data) as CompositeTransformResult<FirStatement> return transformAnnotatedDeclaration(valueParameter, data) as FirStatement
} }
override fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult<FirDeclaration> { override fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): FirDeclaration {
return transformAnnotatedDeclaration(typeAlias, data) return transformAnnotatedDeclaration(typeAlias, data)
} }
override fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult<FirTypeRef> { override fun transformTypeRef(typeRef: FirTypeRef, data: D): FirTypeRef {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return transformAnnotationContainer(typeRef, data) as CompositeTransformResult<FirTypeRef> return transformAnnotationContainer(typeRef, data) as FirTypeRef
} }
override fun transformAnnotatedDeclaration( override fun transformAnnotatedDeclaration(
annotatedDeclaration: FirAnnotatedDeclaration, annotatedDeclaration: FirAnnotatedDeclaration,
data: D data: D
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return transformAnnotationContainer(annotatedDeclaration, data) as CompositeTransformResult<FirDeclaration> return transformAnnotationContainer(annotatedDeclaration, data) as FirDeclaration
} }
override fun transformAnnotationContainer( override fun transformAnnotationContainer(
annotationContainer: FirAnnotationContainer, annotationContainer: FirAnnotationContainer,
data: D data: D
): CompositeTransformResult<FirAnnotationContainer> { ): FirAnnotationContainer {
return annotationContainer.transformAnnotations(this, data).compose() return annotationContainer.transformAnnotations(this, data)
} }
override fun <E : FirElement> transformElement(element: E, data: D): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: D): E {
return element.compose() return element
} }
protected open fun beforeChildren(declaration: FirAnnotatedDeclaration): S? { protected open fun beforeChildren(declaration: FirAnnotatedDeclaration): S? {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt
+4 -6
View File
@@ -15,9 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor
import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
@OptIn(AdapterForResolveProcessor::class) @OptIn(AdapterForResolveProcessor::class)
class FirAnnotationArgumentsResolveProcessor( class FirAnnotationArgumentsResolveProcessor(
@@ -33,12 +31,12 @@ class FirAnnotationArgumentsResolveTransformerAdapter(session: FirSession, scope
private val hasAnnotations = session.registeredPluginAnnotations.annotations.isNotEmpty() private val hasAnnotations = session.registeredPluginAnnotations.annotations.isNotEmpty()
private val predicateBasedProvider = session.predicateBasedProvider private val predicateBasedProvider = session.predicateBasedProvider
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
if (!hasAnnotations || !predicateBasedProvider.fileHasPluginAnnotations(file)) return file.compose() if (!hasAnnotations || !predicateBasedProvider.fileHasPluginAnnotations(file)) return file
return file.transform(transformer, ResolutionMode.ContextIndependent) return file.transform(transformer, ResolutionMode.ContextIndependent)
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt
+43 -45
View File
@@ -19,8 +19,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclaration
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressionsResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressionsResolveTransformer
import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.fir.types.coneTypeSafe import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
class FirAnnotationArgumentsResolveTransformer( class FirAnnotationArgumentsResolveTransformer(
session: FirSession, session: FirSession,
@@ -47,49 +45,49 @@ private class FirDeclarationsResolveTransformerForArgumentAnnotations(
override fun transformWrappedDelegateExpression( override fun transformWrappedDelegateExpression(
wrappedDelegateExpression: FirWrappedDelegateExpression, wrappedDelegateExpression: FirWrappedDelegateExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return wrappedDelegateExpression.compose() return wrappedDelegateExpression
} }
override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement {
return regularClass.transformAnnotations(this, data).transformDeclarations(this, data).compose() return regularClass.transformAnnotations(this, data).transformDeclarations(this, data)
} }
override fun transformAnonymousInitializer( override fun transformAnonymousInitializer(
anonymousInitializer: FirAnonymousInitializer, anonymousInitializer: FirAnonymousInitializer,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
return anonymousInitializer.compose() return anonymousInitializer
} }
override fun transformSimpleFunction( override fun transformSimpleFunction(
simpleFunction: FirSimpleFunction, simpleFunction: FirSimpleFunction,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirSimpleFunction> { ): FirSimpleFunction {
return simpleFunction.transformAnnotations(this, data).compose() return simpleFunction.transformAnnotations(this, data)
} }
override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration {
return constructor.transformAnnotations(this, data).compose() return constructor.transformAnnotations(this, data)
} }
override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement {
return valueParameter.transformAnnotations(this, data).compose() return valueParameter.transformAnnotations(this, data)
} }
override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirProperty> { override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
property.transformAnnotations(this, data) property.transformAnnotations(this, data)
property.transformGetter(this, data) property.transformGetter(this, data)
property.transformSetter(this, data) property.transformSetter(this, data)
return property.compose() return property
} }
override fun transformPropertyAccessor( override fun transformPropertyAccessor(
propertyAccessor: FirPropertyAccessor, propertyAccessor: FirPropertyAccessor,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
propertyAccessor.transformAnnotations(this, data) propertyAccessor.transformAnnotations(this, data)
return propertyAccessor.compose() return propertyAccessor
} }
} }
@@ -99,16 +97,16 @@ private class FirExpressionsResolveTransformerForSpecificAnnotations(
) : FirExpressionsResolveTransformer(transformer) { ) : FirExpressionsResolveTransformer(transformer) {
private var annotationArgumentsMode: Boolean = false private var annotationArgumentsMode: Boolean = false
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement {
if (annotationArgumentsMode) { if (annotationArgumentsMode) {
return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.PartiallyResolved) return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.PartiallyResolved)
} }
annotationCall.transformAnnotationTypeRef(transformer, data) annotationCall.transformAnnotationTypeRef(transformer, data)
val classId = annotationCall.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId val classId = annotationCall.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId
?: return annotationCall.compose() ?: return annotationCall
if (classId.asSingleFqName() !in annotations) { if (classId.asSingleFqName() !in annotations) {
return annotationCall.compose() return annotationCall
} }
annotationArgumentsMode = true annotationArgumentsMode = true
return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.PartiallyResolved).also { return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.PartiallyResolved).also {
@@ -116,82 +114,82 @@ private class FirExpressionsResolveTransformerForSpecificAnnotations(
} }
} }
override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement {
return expression.compose() return expression
} }
override fun FirQualifiedAccessExpression.isAcceptableResolvedQualifiedAccess(): Boolean { override fun FirQualifiedAccessExpression.isAcceptableResolvedQualifiedAccess(): Boolean {
return calleeReference !is FirErrorNamedReference return calleeReference !is FirErrorNamedReference
} }
override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): FirStatement {
return functionCall.compose() return functionCall
} }
override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult<FirStatement> { override fun transformBlock(block: FirBlock, data: ResolutionMode): FirStatement {
return block.compose() return block
} }
override fun transformThisReceiverExpression( override fun transformThisReceiverExpression(
thisReceiverExpression: FirThisReceiverExpression, thisReceiverExpression: FirThisReceiverExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return thisReceiverExpression.compose() return thisReceiverExpression
} }
override fun transformComparisonExpression( override fun transformComparisonExpression(
comparisonExpression: FirComparisonExpression, comparisonExpression: FirComparisonExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return comparisonExpression.compose() return comparisonExpression
} }
override fun transformTypeOperatorCall( override fun transformTypeOperatorCall(
typeOperatorCall: FirTypeOperatorCall, typeOperatorCall: FirTypeOperatorCall,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return typeOperatorCall.compose() return typeOperatorCall
} }
override fun transformCheckNotNullCall( override fun transformCheckNotNullCall(
checkNotNullCall: FirCheckNotNullCall, checkNotNullCall: FirCheckNotNullCall,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return checkNotNullCall.compose() return checkNotNullCall
} }
override fun transformBinaryLogicExpression( override fun transformBinaryLogicExpression(
binaryLogicExpression: FirBinaryLogicExpression, binaryLogicExpression: FirBinaryLogicExpression,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return binaryLogicExpression.compose() return binaryLogicExpression
} }
override fun transformVariableAssignment( override fun transformVariableAssignment(
variableAssignment: FirVariableAssignment, variableAssignment: FirVariableAssignment,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return variableAssignment.compose() return variableAssignment
} }
override fun transformCallableReferenceAccess( override fun transformCallableReferenceAccess(
callableReferenceAccess: FirCallableReferenceAccess, callableReferenceAccess: FirCallableReferenceAccess,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return callableReferenceAccess.compose() return callableReferenceAccess
} }
override fun transformDelegatedConstructorCall( override fun transformDelegatedConstructorCall(
delegatedConstructorCall: FirDelegatedConstructorCall, delegatedConstructorCall: FirDelegatedConstructorCall,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return delegatedConstructorCall.compose() return delegatedConstructorCall
} }
override fun transformAugmentedArraySetCall( override fun transformAugmentedArraySetCall(
augmentedArraySetCall: FirAugmentedArraySetCall, augmentedArraySetCall: FirAugmentedArraySetCall,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirStatement> { ): FirStatement {
return augmentedArraySetCall.compose() return augmentedArraySetCall
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalExtensionStatusProcessor.kt
+20 -22
View File
@@ -15,10 +15,8 @@ import org.jetbrains.kotlin.fir.extensions.statusTransformerExtensions
import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.transformers.FirGlobalResolveProcessor import org.jetbrains.kotlin.fir.resolve.transformers.FirGlobalResolveProcessor
import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
class FirGlobalExtensionStatusProcessor( class FirGlobalExtensionStatusProcessor(
session: FirSession, session: FirSession,
@@ -62,59 +60,59 @@ class FirTransformerBasedExtensionStatusProcessor(
transformStatus(ReplaceStatus, status) transformStatus(ReplaceStatus, status)
} }
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
return element.compose() return element
} }
override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): FirDeclaration {
typeAlias.updateStatus() typeAlias.updateStatus()
return typeAlias.compose() return typeAlias
} }
override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirStatement> { override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement {
regularClass.updateStatus() regularClass.updateStatus()
regularClass.transformDeclarations(this, data) regularClass.transformDeclarations(this, data)
return regularClass.compose() return regularClass
} }
override fun transformConstructor(constructor: FirConstructor, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformConstructor(constructor: FirConstructor, data: Nothing?): FirDeclaration {
constructor.updateStatus() constructor.updateStatus()
return constructor.compose() return constructor
} }
override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformProperty(property: FirProperty, data: Nothing?): FirDeclaration {
property.updateStatus() property.updateStatus()
property.transformGetter(this, data) property.transformGetter(this, data)
property.transformSetter(this, data) property.transformSetter(this, data)
return property.compose() return property
} }
override fun transformField(field: FirField, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformField(field: FirField, data: Nothing?): FirDeclaration {
field.updateStatus() field.updateStatus()
return field.compose() return field
} }
override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): FirDeclaration {
enumEntry.updateStatus() enumEntry.updateStatus()
return enumEntry.compose() return enumEntry
} }
override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): CompositeTransformResult<FirDeclaration> { override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): FirDeclaration {
simpleFunction.updateStatus() simpleFunction.updateStatus()
return simpleFunction.compose() return simpleFunction
} }
} }
} }
private object ReplaceStatus : FirTransformer<FirDeclarationStatus>() { private object ReplaceStatus : FirTransformer<FirDeclarationStatus>() {
override fun <E : FirElement> transformElement(element: E, data: FirDeclarationStatus): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: FirDeclarationStatus): E {
return element.compose() return element
} }
override fun transformDeclarationStatus( override fun transformDeclarationStatus(
declarationStatus: FirDeclarationStatus, declarationStatus: FirDeclarationStatus,
data: FirDeclarationStatus data: FirDeclarationStatus
): CompositeTransformResult<FirDeclarationStatus> { ): FirDeclarationStatus {
return data.compose() return data
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt
+8 -10
View File
@@ -22,8 +22,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirAbstractPhaseTransformer
import org.jetbrains.kotlin.fir.resolve.transformers.FirImportResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.FirImportResolveTransformer
import org.jetbrains.kotlin.fir.resolve.transformers.FirSpecificTypeResolverTransformer import org.jetbrains.kotlin.fir.resolve.transformers.FirSpecificTypeResolverTransformer
import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.FqName
class FirPluginAnnotationsResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) { class FirPluginAnnotationsResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) {
@@ -38,13 +36,13 @@ class FirPluginAnnotationsResolveTransformer(
private val importTransformer = FirPartialImportResolveTransformer(session) private val importTransformer = FirPartialImportResolveTransformer(session)
val extensionService = session.extensionService val extensionService = session.extensionService
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
throw IllegalStateException("Should not be here") throw IllegalStateException("Should not be here")
} }
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> { override fun transformFile(file: FirFile, data: Nothing?): FirFile {
checkSessionConsistency(file) checkSessionConsistency(file)
if (!extensionService.hasPredicateBasedExtensions) return file.compose() if (!extensionService.hasPredicateBasedExtensions) return file
val registeredPluginAnnotations = file.session.registeredPluginAnnotations val registeredPluginAnnotations = file.session.registeredPluginAnnotations
file.replaceResolvePhase(FirResolvePhase.ANNOTATIONS_FOR_PLUGINS) file.replaceResolvePhase(FirResolvePhase.ANNOTATIONS_FOR_PLUGINS)
val newAnnotations = file.resolveAnnotations(registeredPluginAnnotations.annotations, registeredPluginAnnotations.metaAnnotations) val newAnnotations = file.resolveAnnotations(registeredPluginAnnotations.annotations, registeredPluginAnnotations.metaAnnotations)
@@ -55,7 +53,7 @@ class FirPluginAnnotationsResolveTransformer(
val newAnnotationsFqns = newAnnotations.values().mapTo(mutableSetOf()) { it.symbol.classId.asSingleFqName() } val newAnnotationsFqns = newAnnotations.values().mapTo(mutableSetOf()) { it.symbol.classId.asSingleFqName() }
file.resolveAnnotations(newAnnotationsFqns, emptySet()) file.resolveAnnotations(newAnnotationsFqns, emptySet())
} }
return file.compose() return file
} }
private fun FirFile.resolveAnnotations( private fun FirFile.resolveAnnotations(
@@ -107,14 +105,14 @@ private class FirAnnotationResolveTransformer(
override fun transformAnnotationCall( override fun transformAnnotationCall(
annotationCall: FirAnnotationCall, annotationCall: FirAnnotationCall,
data: Multimap<AnnotationFqn, FirRegularClass> data: Multimap<AnnotationFqn, FirRegularClass>
): CompositeTransformResult<FirStatement> { ): FirStatement {
return annotationCall.transformAnnotationTypeRef(typeResolverTransformer, scope).compose() return annotationCall.transformAnnotationTypeRef(typeResolverTransformer, scope)
} }
override fun transformRegularClass( override fun transformRegularClass(
regularClass: FirRegularClass, regularClass: FirRegularClass,
data: Multimap<AnnotationFqn, FirRegularClass> data: Multimap<AnnotationFqn, FirRegularClass>
): CompositeTransformResult<FirStatement> { ): FirStatement {
return super.transformRegularClass(regularClass, data).also { return super.transformRegularClass(regularClass, data).also {
if (regularClass.classKind == ClassKind.ANNOTATION_CLASS && metaAnnotations.isNotEmpty()) { if (regularClass.classKind == ClassKind.ANNOTATION_CLASS && metaAnnotations.isNotEmpty()) {
val annotations = regularClass.annotations.mapNotNull { it.fqName(session) } val annotations = regularClass.annotations.mapNotNull { it.fqName(session) }
@@ -128,7 +126,7 @@ private class FirAnnotationResolveTransformer(
override fun transformAnnotatedDeclaration( override fun transformAnnotatedDeclaration(
annotatedDeclaration: FirAnnotatedDeclaration, annotatedDeclaration: FirAnnotatedDeclaration,
data: Multimap<AnnotationFqn, FirRegularClass> data: Multimap<AnnotationFqn, FirRegularClass>
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
return super.transformAnnotatedDeclaration(annotatedDeclaration, data).also { return super.transformAnnotatedDeclaration(annotatedDeclaration, data).also {
session.predicateBasedProvider.registerAnnotatedDeclaration(annotatedDeclaration, owners) session.predicateBasedProvider.registerAnnotatedDeclaration(annotatedDeclaration, owners)
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultSimpleImportingScope.kt
+1 -1
View File
@@ -20,7 +20,7 @@ class FirDefaultSimpleImportingScope(
) : FirAbstractSimpleImportingScope(session, scopeSession) { ) : FirAbstractSimpleImportingScope(session, scopeSession) {
private fun FirImport.resolve(importResolveTransformer: FirImportResolveTransformer) = private fun FirImport.resolve(importResolveTransformer: FirImportResolveTransformer) =
importResolveTransformer.transformImport(this, null).single as FirResolvedImport importResolveTransformer.transformImport(this, null) as FirResolvedImport
override val simpleImports = run { override val simpleImports = run {
val importResolveTransformer = FirImportResolveTransformer(session) val importResolveTransformer = FirImportResolveTransformer(session)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/FirElement.kt
+2 -3
View File
@@ -5,7 +5,6 @@
package org.jetbrains.kotlin.fir package org.jetbrains.kotlin.fir
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.* import org.jetbrains.kotlin.fir.visitors.*
/* /*
@@ -25,8 +24,8 @@ interface FirElement {
fun acceptChildren(visitor: FirVisitorVoid) = acceptChildren(visitor, null) fun acceptChildren(visitor: FirVisitorVoid) = acceptChildren(visitor, null)
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): CompositeTransformResult<E> = fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): E =
accept(visitor, data) as CompositeTransformResult<E> accept(visitor, data) as E
fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement
} }
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt
+251 -252
View File
File diff suppressed because it is too large Load Diff
compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt
-45
View File
@@ -1,45 +0,0 @@
/*
* Copyright 2000-2018 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.visitors
import org.jetbrains.kotlin.fir.FirElement
sealed class CompositeTransformResult<out T : Any> {
class Single<out T : Any>(val _single: T) : CompositeTransformResult<T>()
class Multiple<out T : Any>(val _list: List<T>) : CompositeTransformResult<T>()
companion object {
fun <T : Any> empty() = Multiple(emptyList<T>())
fun <T : Any> single(t: T) = Single(t)
fun <T : Any> many(l: List<T>) = Multiple(l)
}
@Suppress("UNCHECKED_CAST")
val list: List<T>
get() = when (this) {
is Multiple<*> -> _list as List<T>
else -> error("!")
}
@Suppress("UNCHECKED_CAST")
val single: T
get() = when (this) {
is Single<*> -> _single as T
else -> error("!")
}
val isSingle
get() = this is Single<*>
val isEmpty
get() = this is Multiple<*> && this.list.isEmpty()
}
@Suppress("NOTHING_TO_INLINE")
inline fun <T : FirElement> T.compose() = CompositeTransformResult.single(this)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt
+21 -21
View File
@@ -12,94 +12,94 @@ import org.jetbrains.kotlin.fir.references.FirReference
import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.*
abstract class FirDefaultTransformer<D> : FirTransformer<D>() { abstract class FirDefaultTransformer<D> : FirTransformer<D>() {
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult<FirTypeRef> { override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): FirTypeRef {
return transformTypeRef(implicitTypeRef, data) return transformTypeRef(implicitTypeRef, data)
} }
override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult<FirTypeRef> { override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): FirTypeRef {
return transformTypeRef(resolvedTypeRef, data) return transformTypeRef(resolvedTypeRef, data)
} }
override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult<FirTypeRef> { override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): FirTypeRef {
return transformResolvedTypeRef(errorTypeRef, data) return transformResolvedTypeRef(errorTypeRef, data)
} }
override fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult<FirTypeRef> { override fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): FirTypeRef {
return transformTypeRef(typeRefWithNullability, data) return transformTypeRef(typeRefWithNullability, data)
} }
override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult<FirTypeRef> { override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): FirTypeRef {
return transformTypeRefWithNullability(dynamicTypeRef, data) return transformTypeRefWithNullability(dynamicTypeRef, data)
} }
override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> { override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): FirTypeRef {
return transformTypeRefWithNullability(functionTypeRef, data) return transformTypeRefWithNullability(functionTypeRef, data)
} }
override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult<FirTypeRef> { override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): FirTypeRef {
return transformTypeRefWithNullability(userTypeRef, data) return transformTypeRefWithNullability(userTypeRef, data)
} }
override fun transformCallableReferenceAccess( override fun transformCallableReferenceAccess(
callableReferenceAccess: FirCallableReferenceAccess, callableReferenceAccess: FirCallableReferenceAccess,
data: D data: D
): CompositeTransformResult<FirStatement> { ): FirStatement {
return transformQualifiedAccessExpression(callableReferenceAccess, data) return transformQualifiedAccessExpression(callableReferenceAccess, data)
} }
override fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult<FirStatement> { override fun transformComponentCall(componentCall: FirComponentCall, data: D): FirStatement {
return transformFunctionCall(componentCall, data) return transformFunctionCall(componentCall, data)
} }
override fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult<FirStatement> { override fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): FirStatement {
return transformJump(returnExpression, data) return transformJump(returnExpression, data)
} }
override fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult<FirStatement> { override fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): FirStatement {
return transformJump(continueExpression, data) return transformJump(continueExpression, data)
} }
override fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult<FirStatement> { override fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): FirStatement {
return transformJump(breakExpression, data) return transformJump(breakExpression, data)
} }
override fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): CompositeTransformResult<FirStatement> { override fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): FirStatement {
return transformWrappedArgumentExpression(lambdaArgumentExpression, data) return transformWrappedArgumentExpression(lambdaArgumentExpression, data)
} }
override fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): CompositeTransformResult<FirStatement> { override fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): FirStatement {
return transformWrappedArgumentExpression(spreadArgumentExpression, data) return transformWrappedArgumentExpression(spreadArgumentExpression, data)
} }
override fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult<FirStatement> { override fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): FirStatement {
return transformWrappedArgumentExpression(namedArgumentExpression, data) return transformWrappedArgumentExpression(namedArgumentExpression, data)
} }
override fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult<FirStatement> { override fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): FirStatement {
return transformExpression(errorExpression, data) return transformExpression(errorExpression, data)
} }
override fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): CompositeTransformResult<FirStatement> { override fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): FirStatement {
return transformLoop(errorLoop, data) return transformLoop(errorLoop, data)
} }
override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): CompositeTransformResult<FirReference> { override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): FirReference {
return transformNamedReference(errorNamedReference, data) return transformNamedReference(errorNamedReference, data)
} }
override fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): CompositeTransformResult<FirStatement> { override fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): FirStatement {
return transformFunction(errorFunction, data) return transformFunction(errorFunction, data)
} }
override fun transformErrorResolvedQualifier( override fun transformErrorResolvedQualifier(
errorResolvedQualifier: FirErrorResolvedQualifier, errorResolvedQualifier: FirErrorResolvedQualifier,
data: D data: D
): CompositeTransformResult<FirStatement> { ): FirStatement {
return transformResolvedQualifier(errorResolvedQualifier, data) return transformResolvedQualifier(errorResolvedQualifier, data)
} }
override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): CompositeTransformResult<FirStatement> { override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): FirStatement {
return transformFunctionCall(implicitInvokeCall, data) return transformFunctionCall(implicitInvokeCall, data)
} }
} }
compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformerUtil.kt
+3 -16
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirPureAbstractElement import org.jetbrains.kotlin.fir.FirPureAbstractElement
fun <T : FirElement, D> T.transformSingle(transformer: FirTransformer<D>, data: D): T { fun <T : FirElement, D> T.transformSingle(transformer: FirTransformer<D>, data: D): T {
return (this as FirPureAbstractElement).transform<T, D>(transformer, data).single return (this as FirPureAbstractElement).transform<T, D>(transformer, data)
} }
fun <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirTransformer<D>, data: D) { fun <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirTransformer<D>, data: D) {
@@ -17,20 +17,7 @@ fun <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirTransfor
while (iterator.hasNext()) { while (iterator.hasNext()) {
val next = iterator.next() as FirPureAbstractElement val next = iterator.next() as FirPureAbstractElement
val result = next.transform<T, D>(transformer, data) val result = next.transform<T, D>(transformer, data)
if (result.isSingle) { iterator.set(result)
iterator.set(result.single)
} else {
val resultIterator = result.list.listIterator()
if (!resultIterator.hasNext()) {
iterator.remove()
} else {
iterator.set(resultIterator.next())
}
while (resultIterator.hasNext()) {
iterator.add(resultIterator.next())
}
}
} }
} }
@@ -48,7 +35,7 @@ inline fun <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirT
is TransformData.Data<D> -> data.value is TransformData.Data<D> -> data.value
TransformData.Nothing -> continue TransformData.Nothing -> continue
} }
val result = next.transform<T, D>(transformer, data).single val result = next.transform<T, D>(transformer, data)
iterator.set(result) iterator.set(result)
} }
} }
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt
-1
View File
@@ -60,7 +60,6 @@ val implicitStringTypeRefType = generatedType("types.impl", "FirImplicitStringTy
val implicitUnitTypeRefType = generatedType("types.impl", "FirImplicitUnitTypeRef") val implicitUnitTypeRefType = generatedType("types.impl", "FirImplicitUnitTypeRef")
val resolvePhaseType = type("fir.declarations", "FirResolvePhase") val resolvePhaseType = type("fir.declarations", "FirResolvePhase")
val stubReferenceType = generatedType("references.impl", "FirStubReference") val stubReferenceType = generatedType("references.impl", "FirStubReference")
val compositeTransformResultType = type("fir.visitors", "CompositeTransformResult")
val abstractFirBasedSymbolType = type("fir.symbols", "AbstractFirBasedSymbol") val abstractFirBasedSymbolType = type("fir.symbols", "AbstractFirBasedSymbol")
val backingFieldSymbolType = type("fir.symbols.impl", "FirBackingFieldSymbol") val backingFieldSymbolType = type("fir.symbols.impl", "FirBackingFieldSymbol")
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt
+2 -2
View File
@@ -133,9 +133,9 @@ fun SmartPrinter.printElement(element: Element) {
println("fun acceptChildren(visitor: FirVisitorVoid) = acceptChildren(visitor, null)") println("fun acceptChildren(visitor: FirVisitorVoid) = acceptChildren(visitor, null)")
println() println()
println("@Suppress(\"UNCHECKED_CAST\")") println("@Suppress(\"UNCHECKED_CAST\")")
println("fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): CompositeTransformResult<E> =") println("fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): E =")
withIndent { withIndent {
println("accept(visitor, data) as CompositeTransformResult<E>") println("accept(visitor, data) as E")
} }
println() println()
println("fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement") println("fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement")
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt
+6 -8
View File
@@ -5,7 +5,6 @@
package org.jetbrains.kotlin.fir.tree.generator.printer package org.jetbrains.kotlin.fir.tree.generator.printer
import org.jetbrains.kotlin.fir.tree.generator.compositeTransformResultType
import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
import org.jetbrains.kotlin.fir.tree.generator.model.Element import org.jetbrains.kotlin.fir.tree.generator.model.Element
import org.jetbrains.kotlin.util.SmartPrinter import org.jetbrains.kotlin.util.SmartPrinter
@@ -22,14 +21,13 @@ fun printTransformer(elements: List<Element>, generationPath: File): GeneratedFi
println("package $VISITOR_PACKAGE") println("package $VISITOR_PACKAGE")
println() println()
elements.forEach { println("import ${it.fullQualifiedName}") } elements.forEach { println("import ${it.fullQualifiedName}") }
println("import ${compositeTransformResultType.fullQualifiedName}")
println() println()
printGeneratedMessage() printGeneratedMessage()
println("abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirElement>, D>() {") println("abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {")
println() println()
withIndent { withIndent {
println("abstract fun <E : FirElement> transformElement(element: E, data: D): CompositeTransformResult<E>") println("abstract fun <E : FirElement> transformElement(element: E, data: D): E")
println() println()
for (element in elements) { for (element in elements) {
if (element == AbstractFirTreeBuilder.baseFirElement) continue if (element == AbstractFirTreeBuilder.baseFirElement) continue
@@ -37,8 +35,8 @@ fun printTransformer(elements: List<Element>, generationPath: File): GeneratedFi
print("open fun ") print("open fun ")
element.typeParameters.takeIf { it.isNotBlank() }?.let { print(it) } element.typeParameters.takeIf { it.isNotBlank() }?.let { print(it) }
println( println(
"transform${element.name}($varName: ${element.typeWithArguments}, data: D): CompositeTransformResult<${element.transformerType "transform${element.name}($varName: ${element.typeWithArguments}, data: D): ${element.transformerType
.typeWithArguments}>${element.multipleUpperBoundsList()}{", .typeWithArguments}${element.multipleUpperBoundsList()}{",
) )
withIndent { withIndent {
println("return transformElement($varName, data)") println("return transformElement($varName, data)")
@@ -53,8 +51,8 @@ fun printTransformer(elements: List<Element>, generationPath: File): GeneratedFi
element.typeParameters.takeIf { it.isNotBlank() }?.let { print(it) } element.typeParameters.takeIf { it.isNotBlank() }?.let { print(it) }
println( println(
"visit${element.name}($varName: ${element.typeWithArguments}, data: D): CompositeTransformResult<${element.transformerType "visit${element.name}($varName: ${element.typeWithArguments}, data: D): ${element.transformerType
.typeWithArguments}>${element.multipleUpperBoundsList()}{", .typeWithArguments}${element.multipleUpperBoundsList()}{",
) )
withIndent { withIndent {
println("return transform${element.name}($varName, data)") println("return transform${element.name}($varName, data)")
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/utils.kt
-5
View File
@@ -5,7 +5,6 @@
package org.jetbrains.kotlin.fir.tree.generator.printer package org.jetbrains.kotlin.fir.tree.generator.printer
import org.jetbrains.kotlin.fir.tree.generator.compositeTransformResultType
import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
import org.jetbrains.kotlin.fir.tree.generator.firImplementationDetailType import org.jetbrains.kotlin.fir.tree.generator.firImplementationDetailType
import org.jetbrains.kotlin.fir.tree.generator.model.* import org.jetbrains.kotlin.fir.tree.generator.model.*
@@ -52,10 +51,6 @@ fun Implementation.collectImports(base: List<String> = emptyList(), kind: Import
fun Element.collectImports(): List<String> { fun Element.collectImports(): List<String> {
val baseTypes = parents.mapTo(mutableListOf()) { it.fullQualifiedName } val baseTypes = parents.mapTo(mutableListOf()) { it.fullQualifiedName }
baseTypes += parentsArguments.values.flatMap { it.values }.mapNotNull { it.fullQualifiedName } baseTypes += parentsArguments.values.flatMap { it.values }.mapNotNull { it.fullQualifiedName }
val isBaseFirElement = this == AbstractFirTreeBuilder.baseFirElement
if (isBaseFirElement) {
baseTypes += compositeTransformResultType.fullQualifiedName!!
}
if (needPureAbstractElement) { if (needPureAbstractElement) {
baseTypes += pureAbstractElementType.fullQualifiedName!! baseTypes += pureAbstractElementType.fullQualifiedName!!
} }
idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/element/builder/FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator.kt
+3 -4
View File
@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformerForReturnTypeCalculator import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformerForReturnTypeCalculator
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.idea.fir.low.level.api.lazy.resolve.FirLazyBodiesCalculator import org.jetbrains.kotlin.idea.fir.low.level.api.lazy.resolve.FirLazyBodiesCalculator
fun FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator( fun FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator(
@@ -61,17 +60,17 @@ class FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
override fun transformSimpleFunction( override fun transformSimpleFunction(
simpleFunction: FirSimpleFunction, simpleFunction: FirSimpleFunction,
data: ResolutionMode data: ResolutionMode
): CompositeTransformResult<FirSimpleFunction> { ): FirSimpleFunction {
FirLazyBodiesCalculator.calculateLazyBodiesForFunction(simpleFunction, declarationDesignation) FirLazyBodiesCalculator.calculateLazyBodiesForFunction(simpleFunction, declarationDesignation)
return super.transformSimpleFunction(simpleFunction, data) return super.transformSimpleFunction(simpleFunction, data)
} }
override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> { override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration {
FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(constructor, declarationDesignation) FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(constructor, declarationDesignation)
return super.transformConstructor(constructor, data) return super.transformConstructor(constructor, data)
} }
override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirProperty> { override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
FirLazyBodiesCalculator.calculateLazyBodyForProperty(property, declarationDesignation) FirLazyBodiesCalculator.calculateLazyBodyForProperty(property, declarationDesignation)
return super.transformProperty(property, data) return super.transformProperty(property, data)
} }
idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyBodiesCalculator.kt
+10 -10
View File
@@ -101,14 +101,14 @@ internal object FirLazyBodiesCalculator {
private object FirLazyBodiesCalculatorTransformer : FirTransformer<MutableList<FirDeclaration>>() { private object FirLazyBodiesCalculatorTransformer : FirTransformer<MutableList<FirDeclaration>>() {
override fun transformFile(file: FirFile, data: MutableList<FirDeclaration>): CompositeTransformResult<FirDeclaration> { override fun transformFile(file: FirFile, data: MutableList<FirDeclaration>): FirDeclaration {
file.declarations.forEach { file.declarations.forEach {
it.transformSingle(this, data) it.transformSingle(this, data)
} }
return file.compose() return file
} }
override fun <E : FirElement> transformElement(element: E, data: MutableList<FirDeclaration>): CompositeTransformResult<E> { override fun <E : FirElement> transformElement(element: E, data: MutableList<FirDeclaration>): E {
if (element is FirRegularClass) { if (element is FirRegularClass) {
data.add(element) data.add(element)
element.declarations.forEach { element.declarations.forEach {
@@ -117,33 +117,33 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer<MutableList<F
element.transformChildren(this, data) element.transformChildren(this, data)
data.removeLast() data.removeLast()
} }
return element.compose() return element
} }
override fun transformSimpleFunction( override fun transformSimpleFunction(
simpleFunction: FirSimpleFunction, simpleFunction: FirSimpleFunction,
data: MutableList<FirDeclaration> data: MutableList<FirDeclaration>
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
if (simpleFunction.body is FirLazyBlock) { if (simpleFunction.body is FirLazyBlock) {
FirLazyBodiesCalculator.calculateLazyBodiesForFunction(simpleFunction, data) FirLazyBodiesCalculator.calculateLazyBodiesForFunction(simpleFunction, data)
} }
return simpleFunction.compose() return simpleFunction
} }
override fun transformConstructor( override fun transformConstructor(
constructor: FirConstructor, constructor: FirConstructor,
data: MutableList<FirDeclaration> data: MutableList<FirDeclaration>
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
if (constructor.body is FirLazyBlock) { if (constructor.body is FirLazyBlock) {
FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(constructor, data) FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(constructor, data)
} }
return constructor.compose() return constructor
} }
override fun transformProperty(property: FirProperty, data: MutableList<FirDeclaration>): CompositeTransformResult<FirDeclaration> { override fun transformProperty(property: FirProperty, data: MutableList<FirDeclaration>): FirDeclaration {
if (FirLazyBodiesCalculator.needCalculatingLazyBodyForProperty(property)) { if (FirLazyBodiesCalculator.needCalculatingLazyBodyForProperty(property)) {
FirLazyBodiesCalculator.calculateLazyBodyForProperty(property, data) FirLazyBodiesCalculator.calculateLazyBodyForProperty(property, data)
} }
return property.compose() return property
} }
} }
idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedBodyResolveTransformerForIDE.kt
+1 -3
View File
@@ -15,8 +15,6 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator
import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirTowerDataContextCollector import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirTowerDataContextCollector
@@ -40,7 +38,7 @@ internal class FirDesignatedBodyResolveTransformerForIDE(
private val ideDeclarationTransformer = IDEDeclarationTransformer(designation) private val ideDeclarationTransformer = IDEDeclarationTransformer(designation)
@Suppress("NAME_SHADOWING") @Suppress("NAME_SHADOWING")
override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> = override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration =
ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data -> ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data ->
super.transformDeclarationContent(declaration, data) super.transformDeclarationContent(declaration, data)
} }
idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedContractsResolveTransformerForIDE.kt
+1 -2
View File
@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveTransformer
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
internal class FirDesignatedContractsResolveTransformerForIDE( internal class FirDesignatedContractsResolveTransformerForIDE(
designation: FirDesignation, designation: FirDesignation,
@@ -20,7 +19,7 @@ internal class FirDesignatedContractsResolveTransformerForIDE(
private val ideDeclarationTransformer = IDEDeclarationTransformer(designation) private val ideDeclarationTransformer = IDEDeclarationTransformer(designation)
@Suppress("NAME_SHADOWING") @Suppress("NAME_SHADOWING")
override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> = override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration =
ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data -> ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data ->
super.transformDeclarationContent(declaration, data) super.transformDeclarationContent(declaration, data)
} }
idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedImplicitTypesTransformerForIDE.kt
+1 -3
View File
@@ -14,8 +14,6 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitAwareBodyResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitAwareBodyResolveTransformer
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator
import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirTowerDataContextCollector import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirTowerDataContextCollector
@@ -41,7 +39,7 @@ internal class FirDesignatedImplicitTypesTransformerForIDE(
private val ideDeclarationTransformer = IDEDeclarationTransformer(designation) private val ideDeclarationTransformer = IDEDeclarationTransformer(designation)
@Suppress("NAME_SHADOWING") @Suppress("NAME_SHADOWING")
override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> = override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration =
ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data -> ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data ->
super.transformDeclarationContent(declaration, data) super.transformDeclarationContent(declaration, data)
} }
idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirFileAnnotationsResolveTransformer.kt
+2 -4
View File
@@ -9,8 +9,6 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator
internal class FirFileAnnotationsResolveTransformer( internal class FirFileAnnotationsResolveTransformer(
@@ -29,10 +27,10 @@ internal class FirFileAnnotationsResolveTransformer(
::FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator ::FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator
), ),
) { ) {
override fun transformFile(file: FirFile, data: ResolutionMode): CompositeTransformResult<FirFile> { override fun transformFile(file: FirFile, data: ResolutionMode): FirFile {
return context.withFile(file, components) { return context.withFile(file, components) {
file.transformAnnotations(this, data) file.transformAnnotations(this, data)
file.compose() file
} }
} }
idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/IDEDeclarationTransformer.kt
+5 -8
View File
@@ -10,10 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.PrivateForInline
internal class IDEDeclarationTransformer(private val designation: FirDesignation) { internal class IDEDeclarationTransformer(private val designation: FirDesignation) {
private var isInsideTargetDeclaration: Boolean = false private var isInsideTargetDeclaration: Boolean = false
@@ -32,8 +29,8 @@ internal class IDEDeclarationTransformer(private val designation: FirDesignation
transformer: FirAbstractBodyResolveTransformer, transformer: FirAbstractBodyResolveTransformer,
declaration: FirDeclaration, declaration: FirDeclaration,
data: ResolutionMode, data: ResolutionMode,
transformDeclaration: (FirDeclaration, ResolutionMode) -> CompositeTransformResult<FirDeclaration> transformDeclaration: (FirDeclaration, ResolutionMode) -> FirDeclaration
): CompositeTransformResult<FirDeclaration> { ): FirDeclaration {
return if (designation.canGoNext()) { return if (designation.canGoNext()) {
val declarationToTransform = designation.currentDeclaration val declarationToTransform = designation.currentDeclaration
val isTargetDeclaration = designation.isTargetDeclaration() val isTargetDeclaration = designation.isTargetDeclaration()
@@ -41,12 +38,12 @@ internal class IDEDeclarationTransformer(private val designation: FirDesignation
insideTargetDeclaration(isTargetDeclaration) { insideTargetDeclaration(isTargetDeclaration) {
declarationToTransform.visitNoTransform(transformer, data) declarationToTransform.visitNoTransform(transformer, data)
} }
declaration.compose() declaration
} else { } else {
if (isInsideTargetDeclaration) { if (isInsideTargetDeclaration) {
transformDeclaration(declaration, data) transformDeclaration(declaration, data)
} else { } else {
declaration.compose() declaration
} }
} }
} }
@@ -57,5 +54,5 @@ internal class IDEDeclarationTransformer(private val designation: FirDesignation
private fun <D> FirElement.visitNoTransform(transformer: FirTransformer<D>, data: D) { private fun <D> FirElement.visitNoTransform(transformer: FirTransformer<D>, data: D) {
val result = this.transform<FirElement, D>(transformer, data) val result = this.transform<FirElement, D>(transformer, data)
require(result.single === this) { "become ${result.single}: `${result.single.render()}`, was ${this}: `${this.render()}`" } require(result === this) { "become $result `${result.render()}`, was ${this}: `${this.render()}`" }
} }