From dfd5e80ce9d8fa25de6f1d9d26d4248188587fa2 Mon Sep 17 00:00:00 2001 From: Ilya Chernikov Date: Fri, 9 Apr 2021 16:38:44 +0200 Subject: [PATCH] FIR: Get rid of CompositeTransformResult --- .../resolve/problems/transform.fir.txt | 54 +- .../testData/resolve/problems/transform.kt | 21 +- .../analysis/FirCheckersResolveProcessor.kt | 10 +- .../builder/AbstractRawFirBuilderTestCase.kt | 5 +- .../inference/FirBuilderInferenceSession.kt | 16 +- .../FirAbstractPhaseTransformer.kt | 8 +- .../FirAbstractTreeTransformer.kt | 6 +- ...irAbstractTreeTransformerWithSuperTypes.kt | 3 +- ...rCallCompletionResultsWriterTransformer.kt | 125 +++-- .../FirImportResolveTransformer.kt | 22 +- .../FirSealedClassInheritorsProcessor.kt | 14 +- .../FirSpecificTypeResolverTransformer.kt | 20 +- .../FirStatusResolveTransformer.kt | 60 +-- .../transformers/FirSupertypesResolution.kt | 32 +- .../transformers/FirSyntheticCallGenerator.kt | 10 +- .../transformers/FirTypeResolveTransformer.kt | 54 +- .../FirWhenExhaustivenessTransformer.kt | 8 +- ...egerLiteralTypeApproximationTransformer.kt | 12 +- .../transformers/InvocationKindTransformer.kt | 40 +- .../resolve/transformers/ResolvePhaseUtils.kt | 6 +- .../resolve/transformers/TransformUtils.kt | 50 +- .../body/resolve/FirBodyResolveTransformer.kt | 118 ++-- .../FirBodyResolveTransformerAdapters.kt | 8 +- ...ControlFlowStatementsResolveTransformer.kt | 54 +- .../FirDeclarationsResolveTransformer.kt | 139 +++-- .../FirExpressionsResolveTransformer.kt | 124 ++--- .../body/resolve/FirImplicitBodyResolve.kt | 30 +- .../FirPartialBodyResolveTransformer.kt | 3 +- .../FirContractResolveTransformer.kt | 66 +-- .../FirContractResolveTransformerAdapter.kt | 10 +- ...FirAbstractAnnotationResolveTransformer.kt | 38 +- .../FirAnnotationArgumentsResolveProcessor.kt | 10 +- ...irAnnotationArgumentsResolveTransformer.kt | 88 ++- .../FirGlobalExtensionStatusProcessor.kt | 42 +- .../FirPluginAnnotationsResolveTransformer.kt | 18 +- .../impl/FirDefaultSimpleImportingScope.kt | 2 +- .../org/jetbrains/kotlin/fir/FirElement.kt | 5 +- .../kotlin/fir/visitors/FirTransformer.kt | 503 +++++++++--------- .../fir/visitors/CompositeTransformResult.kt | 45 -- .../fir/visitors/FirDefaultTransformer.kt | 42 +- .../kotlin/fir/visitors/FirTransformerUtil.kt | 19 +- .../kotlin/fir/tree/generator/Types.kt | 1 - .../fir/tree/generator/printer/element.kt | 4 +- .../fir/tree/generator/printer/transformer.kt | 14 +- .../fir/tree/generator/printer/utils.kt | 5 - ...solveTransformerForReturnTypeCalculator.kt | 7 +- .../lazy/resolve/FirLazyBodiesCalculator.kt | 20 +- ...rDesignatedBodyResolveTransformerForIDE.kt | 4 +- ...gnatedContractsResolveTransformerForIDE.kt | 3 +- ...esignatedImplicitTypesTransformerForIDE.kt | 4 +- .../FirFileAnnotationsResolveTransformer.kt | 6 +- .../trasformers/IDEDeclarationTransformer.kt | 13 +- 52 files changed, 913 insertions(+), 1108 deletions(-) delete mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/transform.fir.txt b/compiler/fir/analysis-tests/testData/resolve/problems/transform.fir.txt index a95e3750381..161b5bc5e13 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/transform.fir.txt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/transform.fir.txt @@ -1,50 +1,4 @@ FILE: transform.kt - public sealed class CompositeTransformResult : R|kotlin/Any| { - protected constructor(): R|CompositeTransformResult| { - super() - } - - public final class Single : R|CompositeTransformResult| { - public constructor(_single: R|T|): R|CompositeTransformResult.Single| { - super|>() - } - - public final val _single: R|T| = R|/_single| - public get(): R|T| - - } - - public final class Multiple : R|CompositeTransformResult| { - public constructor(_list: R|kotlin/collections/List|): R|CompositeTransformResult.Multiple| { - super|>() - } - - public final val _list: R|kotlin/collections/List| = R|/_list| - public get(): R|kotlin/collections/List| - - } - - public final companion object Companion : R|kotlin/Any| { - private constructor(): R|CompositeTransformResult.Companion| { - super() - } - - public final fun single(t: R|T|): R|CompositeTransformResult.Single| { - ^single R|SubstitutionOverride|(R|/t|) - } - - public final fun many(l: R|kotlin/collections/List|): R|CompositeTransformResult.Multiple| { - ^many R|SubstitutionOverride|(R|/l|) - } - - } - - public final val single: R|T| - public get(): R|T| { - ^ ((this@R|/CompositeTransformResult| as R|CompositeTransformResult.Single<*>|).R|SubstitutionOverride| as R|T|) - } - - } public abstract interface FirElement : R|kotlin/Any| { public abstract fun accept(visitor: R|FirVisitor|, data: R|D|): R|R| @@ -52,7 +6,7 @@ FILE: transform.kt ^accept this@R|/FirElement|.R|/FirElement.accept|(R|/visitor|, Null(null)) } - public abstract fun transform(visitor: R|FirTransformer|, data: R|D|): R|CompositeTransformResult| + public abstract fun transform(visitor: R|FirTransformer|, data: R|D|): R|E| } public abstract class FirVisitor : R|kotlin/Any| { @@ -67,9 +21,9 @@ FILE: transform.kt } } - public abstract class FirTransformer : R|FirVisitor, D>| { + public abstract class FirTransformer : R|FirVisitor| { public constructor(): R|FirTransformer| { - super, D>|>() + super|>() } } @@ -109,7 +63,7 @@ FILE: transform.kt } public final fun |> R|F|.runSupertypeResolvePhaseForLocalClass(): R|F| { lval applySupertypesTransformer: R|FirApplySupertypesTransformer| = R|/FirApplySupertypesTransformer.FirApplySupertypesTransformer|() - ^runSupertypeResolvePhaseForLocalClass this@R|/runSupertypeResolvePhaseForLocalClass|.R|SubstitutionOverride|>|(R|/applySupertypesTransformer|, Null(null)).R|SubstitutionOverride| + ^runSupertypeResolvePhaseForLocalClass this@R|/runSupertypeResolvePhaseForLocalClass|.R|SubstitutionOverride|(R|/applySupertypesTransformer|, Null(null)) } public abstract class FirPureAbstractElement : R|FirElement| { public constructor(): R|FirPureAbstractElement| { diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/transform.kt b/compiler/fir/analysis-tests/testData/resolve/problems/transform.kt index bb9f322949b..a87acd4fd3e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/transform.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/transform.kt @@ -1,31 +1,16 @@ -sealed class CompositeTransformResult { - - class Single(val _single: T) : CompositeTransformResult() - - class Multiple(val _list: List) : CompositeTransformResult() - - companion object { - fun single(t: T) = Single(t) - fun many(l: List) = Multiple(l) - } - - val single: T - get() = (this as Single<*>)._single as T -} - interface FirElement { fun accept(visitor: FirVisitor, data: D): R fun accept(visitor: FirVisitorVoid) = accept(visitor, null) - fun transform(visitor: FirTransformer, data: D): CompositeTransformResult + fun transform(visitor: FirTransformer, data: D): E } abstract class FirVisitor abstract class FirVisitorVoid : FirVisitor() -abstract class FirTransformer : FirVisitor, D>() +abstract class FirTransformer : FirVisitor() interface FirAnnotationContainer : FirElement { abstract override fun accept(visitor: FirVisitor, data: D): R @@ -59,7 +44,7 @@ private class FirApplySupertypesTransformer() : FirTransformer() fun > F.runSupertypeResolvePhaseForLocalClass(): F { val applySupertypesTransformer = FirApplySupertypesTransformer() - return this.transform(applySupertypesTransformer, null).single + return this.transform(applySupertypesTransformer, null) } abstract class FirPureAbstractElement : FirElement diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/FirCheckersResolveProcessor.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/FirCheckersResolveProcessor.kt index 14c19bf41cd..94d441b9f26 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/FirCheckersResolveProcessor.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/FirCheckersResolveProcessor.kt @@ -13,9 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.resolve.ScopeSession 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.compose class FirCheckersResolveProcessor( session: FirSession, @@ -27,12 +25,12 @@ class FirCheckersResolveProcessor( } class FirCheckersRunnerTransformer(private val diagnosticCollector: AbstractDiagnosticCollector) : FirTransformer() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { + override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration { diagnosticCollector.collectDiagnostics(file) - return file.compose() + return file } } \ No newline at end of file diff --git a/compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt b/compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt index 59d87d54ab7..c93d34223cd 100644 --- a/compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt +++ b/compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt @@ -28,7 +28,6 @@ import org.jetbrains.kotlin.fir.session.FirSessionFactory import org.jetbrains.kotlin.fir.types.FirTypeProjection import org.jetbrains.kotlin.fir.types.FirTypeRef 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.FirVisitorVoid import org.jetbrains.kotlin.parsing.KotlinParserDefinition @@ -148,13 +147,13 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase( private class ConsistencyTransformer : FirTransformer() { var result = hashSetOf() - override fun transformElement(element: E, data: Unit): CompositeTransformResult { + override fun transformElement(element: E, data: Unit): E { if (!result.add(element)) { throwTwiceVisitingError(element) } else { element.transformChildren(this, Unit) } - return CompositeTransformResult.single(element) + return element } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt index 24f1203dfa0..550d2899ada 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt @@ -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.substitution.ConeSubstitutor 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.compose import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.resolve.calls.inference.buildAbstractResultingSubstitutor @@ -257,18 +255,18 @@ class FirStubTypeTransformer( private val substitutor: ConeSubstitutor ) : FirDefaultTransformer() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { + override fun transformElement(element: E, data: Nothing?): E { @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 = + override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?): FirTypeRef = substitutor.substituteOrNull(resolvedTypeRef.type)?.let { - resolvedTypeRef.withReplacedConeType(it).compose() - } ?: resolvedTypeRef.compose() + resolvedTypeRef.withReplacedConeType(it) + } ?: resolvedTypeRef - override fun transformArgumentList(argumentList: FirArgumentList, data: Nothing?): CompositeTransformResult = - argumentList.transformArguments(this, data).compose() + override fun transformArgumentList(argumentList: FirArgumentList, data: Nothing?): FirArgumentList = + argumentList.transformArguments(this, data) } private val BUILDER_INFERENCE_ANNOTATION_CLASS_ID = ClassId.topLevel(BUILDER_INFERENCE_ANNOTATION_FQ_NAME) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractPhaseTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractPhaseTransformer.kt index 4efc5247bf4..5cd991f4d1a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractPhaseTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractPhaseTransformer.kt @@ -9,8 +9,6 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer abstract class FirAbstractPhaseTransformer( @@ -27,15 +25,15 @@ abstract class FirAbstractPhaseTransformer( } } - override fun transformFile(file: FirFile, data: D): CompositeTransformResult { + override fun transformFile(file: FirFile, data: D): FirFile { checkSessionConsistency(file) file.replaceResolvePhase(transformerPhase) @Suppress("UNCHECKED_CAST") - return super.transformFile(file, data) as CompositeTransformResult + return super.transformFile(file, data) as FirFile } - override fun transformDeclaration(declaration: FirDeclaration, data: D): CompositeTransformResult { + override fun transformDeclaration(declaration: FirDeclaration, data: D): FirDeclaration { declaration.replaceResolvePhase(transformerPhase) return super.transformDeclaration(declaration, data) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformer.kt index 1adcc313d87..8cdf8bd232f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformer.kt @@ -7,12 +7,10 @@ package org.jetbrains.kotlin.fir.resolve.transformers import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult -import org.jetbrains.kotlin.fir.visitors.compose abstract class FirAbstractTreeTransformer(phase: FirResolvePhase) : FirAbstractPhaseTransformer(phase) { - override fun transformElement(element: E, data: D): CompositeTransformResult { + override fun transformElement(element: E, data: D): E { @Suppress("UNCHECKED_CAST") - return (element.transformChildren(this, data) as E).compose() + return (element.transformChildren(this, data) as E) } } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt index 45a4c853a14..d306a2cbccd 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt @@ -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.ConeKotlinType import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType -import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult abstract class FirAbstractTreeTransformerWithSuperTypes( phase: FirResolvePhase, @@ -50,7 +49,7 @@ abstract class FirAbstractTreeTransformerWithSuperTypes( protected fun resolveNestedClassesSupertypes( firClass: FirClass<*>, data: Nothing? - ): CompositeTransformResult { + ): FirStatement { firClass.replaceResolvePhase(transformerPhase) return withScopeCleanup { // Otherwise annotations may try to resolve diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index c4863537ff7..8e21b0ce4b0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt @@ -123,14 +123,14 @@ class FirCallCompletionResultsWriterTransformer( override fun transformQualifiedAccessExpression( qualifiedAccessExpression: FirQualifiedAccessExpression, data: ExpectedArgumentType?, - ): CompositeTransformResult { + ): FirStatement { val calleeReference = qualifiedAccessExpression.calleeReference as? FirNamedReferenceWithCandidate ?: return run { if (mode == Mode.DelegatedPropertyCompletion) { val typeUpdater = TypeUpdaterForDelegateArguments() qualifiedAccessExpression.transformSingle(typeUpdater, null) } - qualifiedAccessExpression.compose() + qualifiedAccessExpression } val result = prepareQualifiedTransform(qualifiedAccessExpression, calleeReference) val typeRef = result.typeRef as FirResolvedTypeRef @@ -147,12 +147,12 @@ class FirCallCompletionResultsWriterTransformer( result.transformExplicitReceiver(typeUpdater, null) } - return result.compose() + return result } - override fun transformFunctionCall(functionCall: FirFunctionCall, data: ExpectedArgumentType?): CompositeTransformResult { + override fun transformFunctionCall(functionCall: FirFunctionCall, data: ExpectedArgumentType?): FirStatement { val calleeReference = functionCall.calleeReference as? FirNamedReferenceWithCandidate - ?: return functionCall.compose() + ?: return functionCall var result = prepareQualifiedTransform(functionCall, calleeReference) val typeRef = result.typeRef as FirResolvedTypeRef val subCandidate = calleeReference.candidate @@ -209,11 +209,11 @@ class FirCallCompletionResultsWriterTransformer( if (enableArrayOfCallTransformation) { arrayOfCallTransformer.toArrayOfCall(result)?.let { - return it.compose() + return it } } - return result.compose() + return result } private val AbstractFirBasedSymbol<*>.isArrayConstructorWithLambda: Boolean @@ -226,9 +226,9 @@ class FirCallCompletionResultsWriterTransformer( override fun transformAnnotationCall( annotationCall: FirAnnotationCall, data: ExpectedArgumentType? - ): CompositeTransformResult { + ): FirStatement { val calleeReference = annotationCall.calleeReference as? FirNamedReferenceWithCandidate - ?: return annotationCall.compose() + ?: return annotationCall annotationCall.transformCalleeReference( StoreCalleeReference, calleeReference.toResolvedReference(), @@ -256,7 +256,7 @@ class FirCallCompletionResultsWriterTransformer( annotationCall.replaceArgumentList(buildResolvedArgumentList(it)) } } - return annotationCall.compose() + return annotationCall } private fun Candidate.handleVarargs() { @@ -295,7 +295,7 @@ class FirCallCompletionResultsWriterTransformer( override fun transformSafeCallExpression( safeCallExpression: FirSafeCallExpression, data: ExpectedArgumentType? - ): CompositeTransformResult { + ): FirStatement { safeCallExpression.transformRegularQualifiedAccess( this, data?.getExpectedType( @@ -305,15 +305,15 @@ class FirCallCompletionResultsWriterTransformer( safeCallExpression.propagateTypeFromQualifiedAccessAfterNullCheck(safeCallExpression.receiver, session) - return safeCallExpression.compose() + return safeCallExpression } override fun transformCallableReferenceAccess( callableReferenceAccess: FirCallableReferenceAccess, data: ExpectedArgumentType?, - ): CompositeTransformResult { + ): FirStatement { val calleeReference = - callableReferenceAccess.calleeReference as? FirNamedReferenceWithCandidate ?: return callableReferenceAccess.compose() + callableReferenceAccess.calleeReference as? FirNamedReferenceWithCandidate ?: return callableReferenceAccess val subCandidate = calleeReference.candidate val typeArguments = computeTypeArguments(callableReferenceAccess, subCandidate) @@ -338,39 +338,38 @@ class FirCallCompletionResultsWriterTransformer( }, ).transformDispatchReceiver(StoreReceiver, subCandidate.dispatchReceiverExpression()) .transformExtensionReceiver(StoreReceiver, subCandidate.extensionReceiverExpression()) - .compose() } override fun transformVariableAssignment( variableAssignment: FirVariableAssignment, data: ExpectedArgumentType?, - ): CompositeTransformResult { + ): FirStatement { val calleeReference = variableAssignment.calleeReference as? FirNamedReferenceWithCandidate - ?: return variableAssignment.compose() + ?: return variableAssignment val typeArguments = computeTypeArguments(variableAssignment, calleeReference.candidate) return variableAssignment.transformCalleeReference( StoreCalleeReference, calleeReference.toResolvedReference(), ).apply { replaceTypeArguments(typeArguments) - }.compose() + } } private inner class TypeUpdaterForDelegateArguments : FirTransformer() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } override fun transformQualifiedAccessExpression( qualifiedAccessExpression: FirQualifiedAccessExpression, data: Nothing? - ): CompositeTransformResult { + ): FirStatement { 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) qualifiedAccessExpression.replaceTypeRef(resolvedTypeRef) session.lookupTracker?.recordTypeResolveAsLookup(resolvedTypeRef, qualifiedAccessExpression.source, null) - return qualifiedAccessExpression.compose() + return qualifiedAccessExpression } } @@ -400,9 +399,9 @@ class FirCallCompletionResultsWriterTransformer( override fun transformDelegatedConstructorCall( delegatedConstructorCall: FirDelegatedConstructorCall, data: ExpectedArgumentType?, - ): CompositeTransformResult { + ): FirStatement { val calleeReference = - delegatedConstructorCall.calleeReference as? FirNamedReferenceWithCandidate ?: return delegatedConstructorCall.compose() + delegatedConstructorCall.calleeReference as? FirNamedReferenceWithCandidate ?: return delegatedConstructorCall val subCandidate = calleeReference.candidate val argumentsMapping = runIf(!calleeReference.isError) { calleeReference.candidate.createArgumentsMapping() } @@ -420,7 +419,7 @@ class FirCallCompletionResultsWriterTransformer( return delegatedConstructorCall.transformCalleeReference( StoreCalleeReference, calleeReference.toResolvedReference(), - ).compose() + ) } private fun computeTypeArguments( @@ -475,7 +474,7 @@ class FirCallCompletionResultsWriterTransformer( override fun transformAnonymousFunction( anonymousFunction: FirAnonymousFunction, data: ExpectedArgumentType?, - ): CompositeTransformResult { + ): FirStatement { // 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 // Control flow info is necessary prerequisite because we collect return expressions in that function @@ -542,7 +541,7 @@ class FirCallCompletionResultsWriterTransformer( expression.transform(this, finalType?.toExpectedType()) } - val resultFunction = result.single + val resultFunction = result if (resultFunction.returnTypeRef.coneTypeSafe() != null) { val lastExpressionType = (returnExpressionsOfAnonymousFunction.lastOrNull() as? FirExpression) @@ -563,44 +562,44 @@ class FirCallCompletionResultsWriterTransformer( private fun transformImplicitTypeRefInAnonymousFunction( anonymousFunction: FirAnonymousFunction - ): CompositeTransformResult { + ): FirStatement { val implicitTypeTransformer = object : FirDefaultTransformer() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { + override fun transformElement(element: E, data: Nothing?): E { @Suppress("UNCHECKED_CAST") - return (element.transformChildren(this, data) as E).compose() + return (element.transformChildren(this, data) as E) } override fun transformImplicitTypeRef( implicitTypeRef: FirImplicitTypeRef, data: Nothing? - ): CompositeTransformResult = + ): FirTypeRef = buildErrorTypeRef { source = implicitTypeRef.source // 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) - }.compose() + } } // NB: if we transform simply all children, there would be too many type error reports. anonymousFunction.transformReturnTypeRef(implicitTypeTransformer, null) anonymousFunction.transformValueParameters(implicitTypeTransformer, null) anonymousFunction.transformBody(implicitTypeTransformer, null) - return anonymousFunction.compose() + return anonymousFunction } override fun transformReturnExpression( returnExpression: FirReturnExpression, data: ExpectedArgumentType? - ): CompositeTransformResult { + ): FirStatement { val labeledElement = returnExpression.target.labeledElement if (labeledElement is FirAnonymousFunction) { - return returnExpression.compose() + return returnExpression } return super.transformReturnExpression(returnExpression, data) } - override fun transformBlock(block: FirBlock, data: ExpectedArgumentType?): CompositeTransformResult { + override fun transformBlock(block: FirBlock, data: ExpectedArgumentType?): FirStatement { val initialType = block.resultType.coneTypeSafe() if (initialType != null) { val finalType = finalSubstitutor.substituteOrNull(initialType) @@ -615,7 +614,7 @@ class FirCallCompletionResultsWriterTransformer( if (block.resultType is FirErrorTypeRef) { block.writeResultType(session) } - return block.compose() + return block } // Transformations for synthetic calls generated by FirSyntheticCallGenerator @@ -623,41 +622,41 @@ class FirCallCompletionResultsWriterTransformer( override fun transformWhenExpression( whenExpression: FirWhenExpression, data: ExpectedArgumentType? - ): CompositeTransformResult { + ): FirStatement { return transformSyntheticCall(whenExpression, data) } override fun transformTryExpression( tryExpression: FirTryExpression, data: ExpectedArgumentType? - ): CompositeTransformResult { + ): FirStatement { return transformSyntheticCall(tryExpression, data) } override fun transformCheckNotNullCall( checkNotNullCall: FirCheckNotNullCall, data: ExpectedArgumentType? - ): CompositeTransformResult { + ): FirStatement { return transformSyntheticCall(checkNotNullCall, data) } override fun transformElvisExpression( elvisExpression: FirElvisExpression, data: ExpectedArgumentType? - ): CompositeTransformResult { + ): FirStatement { return transformSyntheticCall(elvisExpression, data) } private inline fun transformSyntheticCall( syntheticCall: D, data: ExpectedArgumentType?, - ): CompositeTransformResult where D : FirResolvable, D : FirExpression { + ): FirStatement where D : FirResolvable, D : FirExpression { val calleeReference = syntheticCall.calleeReference as? FirNamedReferenceWithCandidate val declaration = calleeReference?.candidate?.symbol?.fir as? FirSimpleFunction if (calleeReference == null || declaration == null) { transformSyntheticCallChildren(syntheticCall, data) - return syntheticCall.compose() + return syntheticCall } val typeRef = typeCalculator.tryCalculateReturnType(declaration) @@ -667,7 +666,7 @@ class FirCallCompletionResultsWriterTransformer( return (syntheticCall.transformCalleeReference( StoreCalleeReference, calleeReference.toResolvedReference(), - ) as D).compose() + ) as D) } private inline fun transformSyntheticCallChildren( @@ -692,20 +691,20 @@ class FirCallCompletionResultsWriterTransformer( override fun transformConstExpression( constExpression: FirConstExpression, data: ExpectedArgumentType?, - ): CompositeTransformResult { - if (data == ExpectedArgumentType.NoApproximation) return constExpression.compose() - return constExpression.approximateIfIsIntegerConst(data?.getExpectedType(constExpression)).compose() + ): FirStatement { + if (data == ExpectedArgumentType.NoApproximation) return constExpression + return constExpression.approximateIfIsIntegerConst(data?.getExpectedType(constExpression)) } - override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: ExpectedArgumentType?): CompositeTransformResult { - if (arrayOfCall.typeRef !is FirImplicitTypeRef) return arrayOfCall.compose() + override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: ExpectedArgumentType?): FirStatement { + if (arrayOfCall.typeRef !is FirImplicitTypeRef) return arrayOfCall val expectedArrayType = data?.getExpectedType(arrayOfCall) val expectedArrayElementType = expectedArrayType?.arrayElementType() arrayOfCall.transformChildren(this, expectedArrayElementType?.toExpectedType()) val arrayElementType = session.inferenceComponents.ctx.commonSuperTypeOrNull(arrayOfCall.arguments.map { it.typeRef.coneType }) ?: session.builtinTypes.nullableAnyType.type arrayOfCall.resultType = arrayOfCall.typeRef.resolvedTypeFromPrototype(arrayElementType.createArrayType()) - return arrayOfCall.compose() + return arrayOfCall } 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() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): CompositeTransformResult { + override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): FirDeclaration { simpleFunction.transformReturnTypeRef(this, data) simpleFunction.transformValueParameters(this, data) simpleFunction.transformReceiverTypeRef(this, data) - return simpleFunction.compose() + return simpleFunction } - override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: Nothing?): FirDeclaration { property.transformGetter(this, data) property.transformSetter(this, data) property.transformReturnTypeRef(this, data) property.transformReceiverTypeRef(this, data) - return property.compose() + return property } override fun transformPropertyAccessor( propertyAccessor: FirPropertyAccessor, data: Nothing? - ): CompositeTransformResult { + ): FirDeclaration { propertyAccessor.transformReturnTypeRef(this, data) propertyAccessor.transformValueParameters(this, data) - return propertyAccessor.compose() + return propertyAccessor } override fun transformValueParameter( valueParameter: FirValueParameter, data: Nothing? - ): CompositeTransformResult { + ): FirStatement { valueParameter.transformReturnTypeRef(this, data) - return valueParameter.compose() + return valueParameter } - override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult { + override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): FirTypeRef { return finalSubstitutor.substituteOrNull(typeRef.coneType)?.let { typeRef.resolvedTypeFromPrototype(it) - }?.compose() ?: typeRef.compose() + } ?: typeRef } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt index f0277c56bb5..f1d8a4d1dc9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt @@ -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.symbolProvider 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.FqName @@ -29,8 +27,8 @@ open class FirImportResolveTransformer protected constructor( final override val session: FirSession, phase: FirResolvePhase ) : FirAbstractTreeTransformer(phase) { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } constructor(session: FirSession) : this(session, FirResolvePhase.IMPORTS) @@ -39,7 +37,7 @@ open class FirImportResolveTransformer protected constructor( private var currentFile: FirFile? = null - override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { + override fun transformFile(file: FirFile, data: Nothing?): FirFile { checkSessionConsistency(file) file.replaceResolvePhase(transformerPhase) return file.also { @@ -50,13 +48,13 @@ open class FirImportResolveTransformer protected constructor( } finally { currentFile = prevValue } - }.compose() + } } - override fun transformImport(import: FirImport, data: Nothing?): CompositeTransformResult { - val fqName = import.importedFqName?.takeUnless { it.isRoot } ?: return import.compose() + override fun transformImport(import: FirImport, data: Nothing?): FirImport { + val fqName = import.importedFqName?.takeUnless { it.isRoot } ?: return import - if (!fqName.isAcceptable) return import.compose() + if (!fqName.isAcceptable) return import if (import.isAllUnder) { return transformImportForFqName(fqName, import) @@ -72,13 +70,13 @@ open class FirImportResolveTransformer protected constructor( protected open val FqName.isAcceptable: Boolean get() = true - private fun transformImportForFqName(fqName: FqName, delegate: FirImport): CompositeTransformResult { - val (packageFqName, relativeClassFqName) = resolveToPackageOrClass(symbolProvider, fqName) ?: return delegate.compose() + private fun transformImportForFqName(fqName: FqName, delegate: FirImport): FirImport { + val (packageFqName, relativeClassFqName) = resolveToPackageOrClass(symbolProvider, fqName) ?: return delegate return buildResolvedImport { this.delegate = delegate this.packageFqName = packageFqName relativeClassName = relativeClassFqName - }.compose() + } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt index b2339c685bc..7e0b26a4aae 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt @@ -74,23 +74,23 @@ class FirSealedClassInheritorsProcessor( } class InheritorsTransformer(private val inheritorsMap: MutableMap>) : FirTransformer() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { - return (file.transformChildren(this, data) as FirFile).compose() + override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration { + return (file.transformChildren(this, data) as FirFile) } - override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult { + override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement { if (regularClass.modality == Modality.SEALED) { val inheritors = inheritorsMap.remove(regularClass) if (inheritors != null) { regularClass.setSealedClassInheritors(inheritors) } } - if (inheritorsMap.isEmpty()) return regularClass.compose() - return (regularClass.transformChildren(this, data) as FirRegularClass).compose() + if (inheritorsMap.isEmpty()) return regularClass + return (regularClass.transformChildren(this, data) as FirRegularClass) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt index 0f5b48e0e28..987019d86f1 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt @@ -15,8 +15,6 @@ import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef 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 class FirSpecificTypeResolverTransformer( @@ -55,7 +53,7 @@ class FirSpecificTypeResolverTransformer( } @OptIn(PrivateForInline::class) - override fun transformTypeRef(typeRef: FirTypeRef, data: FirScope): CompositeTransformResult { + override fun transformTypeRef(typeRef: FirTypeRef, data: FirScope): FirResolvedTypeRef { session.lookupTracker?.recordTypeLookup(typeRef, data.scopeOwnerLookupNames, currentFile?.source) typeRef.transformChildren(this, data) return transformType(typeRef, typeResolver.resolveType(typeRef, data, areBareTypesAllowed)) @@ -65,7 +63,7 @@ class FirSpecificTypeResolverTransformer( override fun transformFunctionTypeRef( functionTypeRef: FirFunctionTypeRef, data: FirScope - ): CompositeTransformResult { + ): FirResolvedTypeRef { functionTypeRef.transformChildren(this, data) session.lookupTracker?.recordTypeLookup(functionTypeRef, data.scopeOwnerLookupNames, currentFile?.source) val resolvedType = typeResolver.resolveType(functionTypeRef, data, areBareTypesAllowed).takeIfAcceptable() @@ -82,10 +80,10 @@ class FirSpecificTypeResolverTransformer( diagnostic = (resolvedType as? ConeClassErrorType)?.diagnostic ?: ConeSimpleDiagnostic("Unresolved functional type: ${functionTypeRef.render()}") } - }.compose() + } } - private fun transformType(typeRef: FirTypeRef, resolvedType: ConeKotlinType): CompositeTransformResult { + private fun transformType(typeRef: FirTypeRef, resolvedType: ConeKotlinType): FirResolvedTypeRef { return if (resolvedType !is ConeClassErrorType) { buildResolvedTypeRef { source = typeRef.source @@ -113,18 +111,18 @@ class FirSpecificTypeResolverTransformer( diagnostic = resolvedType.diagnostic } - }.compose() + } } private fun ConeKotlinType.takeIfAcceptable(): ConeKotlinType? = this.takeUnless { !errorTypeAsResolved && it is ConeClassErrorType } - override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: FirScope): CompositeTransformResult { - return resolvedTypeRef.compose() + override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: FirScope): FirTypeRef { + return resolvedTypeRef } - override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: FirScope): CompositeTransformResult { - return implicitTypeRef.compose() + override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: FirScope): FirTypeRef { + return implicitTypeRef } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt index d4538c98811..c18621cdada 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt @@ -18,8 +18,6 @@ import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.coneType 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 @OptIn(AdapterForResolveProcessor::class) @@ -52,7 +50,7 @@ fun > F.runStatusResolveForLocalClass( FirCompositeScope(scopesForLocalClass) ) - return this.transform(transformer, null).single + return this.transform(transformer, null) } abstract class ResolvedStatusCalculator { @@ -96,7 +94,7 @@ class FirStatusResolveTransformer( override fun transformRegularClass( regularClass: FirRegularClass, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirStatement { val computationStatus = statusComputationSession.startComputing(regularClass) forceResolveStatusesOfSupertypes(regularClass) /* @@ -155,8 +153,8 @@ private class FirDesignatedStatusResolveTransformer( override fun transformRegularClass( regularClass: FirRegularClass, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { - if (shouldSkipClass(regularClass)) return regularClass.compose() + ): FirStatement { + if (shouldSkipClass(regularClass)) return regularClass regularClass.symbol.ensureResolved(FirResolvePhase.TYPES, session) val classLocated = this.classLocated /* @@ -255,7 +253,7 @@ abstract class AbstractFirStatusResolveTransformer( protected abstract fun FirDeclaration.needResolveMembers(): Boolean protected abstract fun FirDeclaration.needResolveNestedClassifiers(): Boolean - override fun transformFile(file: FirFile, data: FirResolvedDeclarationStatus?): CompositeTransformResult { + override fun transformFile(file: FirFile, data: FirResolvedDeclarationStatus?): FirFile { file.replaceResolvePhase(transformerPhase) if (file.needResolveMembers()) { for (declaration in file.declarations) { @@ -271,20 +269,20 @@ abstract class AbstractFirStatusResolveTransformer( } } } - return file.compose() + return file } override fun transformDeclarationStatus( declarationStatus: FirDeclarationStatus, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { - return (data ?: declarationStatus).compose() + ): FirDeclarationStatus { + return (data ?: declarationStatus) } private inline fun storeClass( klass: FirClass<*>, - computeResult: () -> CompositeTransformResult - ): CompositeTransformResult { + computeResult: () -> FirDeclaration + ): FirDeclaration { classes += klass val result = computeResult() classes.removeAt(classes.lastIndex) @@ -294,7 +292,7 @@ abstract class AbstractFirStatusResolveTransformer( override fun transformDeclaration( declaration: FirDeclaration, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirDeclaration { declaration.replaceResolvePhase(transformerPhase) return when (declaration) { is FirCallableDeclaration<*> -> { @@ -305,7 +303,7 @@ abstract class AbstractFirStatusResolveTransformer( } } } - declaration.compose() + declaration } else -> { transformElement(declaration, data) @@ -316,7 +314,7 @@ abstract class AbstractFirStatusResolveTransformer( override fun transformTypeAlias( typeAlias: FirTypeAlias, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirDeclaration { typeAlias.typeParameters.forEach { transformDeclaration(it, data) } typeAlias.transformStatus(this, statusResolver.resolveStatus(typeAlias, containingClass, isLocal = false)) return transformDeclaration(typeAlias, data) @@ -325,12 +323,12 @@ abstract class AbstractFirStatusResolveTransformer( abstract override fun transformRegularClass( regularClass: FirRegularClass, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult + ): FirStatement override fun transformAnonymousObject( anonymousObject: FirAnonymousObject, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirStatement { @Suppress("UNCHECKED_CAST") return transformClass(anonymousObject, data) } @@ -339,7 +337,7 @@ abstract class AbstractFirStatusResolveTransformer( override fun > transformClass( klass: FirClass, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirStatement { return storeClass(klass) { klass.typeParameters.forEach { it.transformSingle(this, data) } klass.replaceResolvePhase(transformerPhase) @@ -355,8 +353,8 @@ abstract class AbstractFirStatusResolveTransformer( } } } - klass.compose() - } as CompositeTransformResult + klass + } as FirStatement } protected fun updateResolvePhaseOfMembers(regularClass: FirRegularClass) { @@ -447,7 +445,7 @@ abstract class AbstractFirStatusResolveTransformer( override fun transformConstructor( constructor: FirConstructor, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirDeclaration { constructor.transformStatus(this, statusResolver.resolveStatus(constructor, containingClass, isLocal = false)) return transformDeclaration(constructor, data) } @@ -455,7 +453,7 @@ abstract class AbstractFirStatusResolveTransformer( override fun transformSimpleFunction( simpleFunction: FirSimpleFunction, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirDeclaration { simpleFunction.replaceResolvePhase(transformerPhase) simpleFunction.transformStatus(this, statusResolver.resolveStatus(simpleFunction, containingClass, isLocal = false)) return transformDeclaration(simpleFunction, data) @@ -464,20 +462,20 @@ abstract class AbstractFirStatusResolveTransformer( override fun transformProperty( property: FirProperty, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirDeclaration { property.replaceResolvePhase(transformerPhase) property.transformStatus(this, statusResolver.resolveStatus(property, containingClass, isLocal = false)) property.getter?.let { transformPropertyAccessor(it, property) } property.setter?.let { transformPropertyAccessor(it, property) } - return property.compose() + return property } override fun transformField( field: FirField, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirDeclaration { field.transformStatus(this, statusResolver.resolveStatus(field, containingClass, isLocal = false)) return transformDeclaration(field, data) } @@ -485,7 +483,7 @@ abstract class AbstractFirStatusResolveTransformer( override fun transformEnumEntry( enumEntry: FirEnumEntry, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirDeclaration { enumEntry.transformStatus(this, statusResolver.resolveStatus(enumEntry, containingClass, isLocal = false)) return transformDeclaration(enumEntry, data) } @@ -493,19 +491,19 @@ abstract class AbstractFirStatusResolveTransformer( override fun transformValueParameter( valueParameter: FirValueParameter, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirStatement { @Suppress("UNCHECKED_CAST") - return transformDeclaration(valueParameter, data) as CompositeTransformResult + return transformDeclaration(valueParameter, data) as FirStatement } override fun transformTypeParameter( typeParameter: FirTypeParameter, data: FirResolvedDeclarationStatus? - ): CompositeTransformResult { + ): FirDeclaration { return transformDeclaration(typeParameter, data) } - override fun transformBlock(block: FirBlock, data: FirResolvedDeclarationStatus?): CompositeTransformResult { - return block.compose() + override fun transformBlock(block: FirBlock, data: FirResolvedDeclarationStatus?): FirStatement { + return block } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt index 27fc9c090bc..73efd83e166 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt @@ -46,11 +46,11 @@ class FirSupertypeResolverTransformer( private val supertypeResolverVisitor = FirSupertypeResolverVisitor(session, supertypeComputationSession, scopeSession) private val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession) - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { + override fun transformFile(file: FirFile, data: Nothing?): FirFile { checkSessionConsistency(file) file.accept(supertypeResolverVisitor) supertypeComputationSession.breakLoops(session) @@ -75,26 +75,26 @@ fun > F.runSupertypeResolvePhaseForLocalClass( supertypeComputationSession.breakLoops(session) val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession) - return this.transform(applySupertypesTransformer, null).single + return this.transform(applySupertypesTransformer, null) } private class FirApplySupertypesTransformer( private val supertypeComputationSession: SupertypeComputationSession ) : FirDefaultTransformer() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { + override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration { 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 { + override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement { applyResolvedSupertypesToClass(regularClass) - return (regularClass.transformChildren(this, null) as FirRegularClass).compose() + return (regularClass.transformChildren(this, null) as FirRegularClass) } private fun applyResolvedSupertypesToClass(firClass: FirClass<*>) { @@ -107,7 +107,7 @@ private class FirApplySupertypesTransformer( firClass.replaceResolvePhase(FirResolvePhase.SUPER_TYPES) } - override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): CompositeTransformResult { + override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): FirStatement { applyResolvedSupertypesToClass(anonymousObject) return super.transformAnonymousObject(anonymousObject, data) @@ -121,8 +121,8 @@ private class FirApplySupertypesTransformer( return status.supertypeRefs } - override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult { - if (typeAlias.expandedTypeRef is FirResolvedTypeRef) return typeAlias.compose() + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): FirDeclaration { + if (typeAlias.expandedTypeRef is FirResolvedTypeRef) return typeAlias val supertypeRefs = getResolvedSupertypeRefs(typeAlias) assert(supertypeRefs.size == 1) { @@ -133,7 +133,7 @@ private class FirApplySupertypesTransformer( typeAlias.replaceExpandedTypeRef(supertypeRefs[0]) 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 */ supertypeRefs.createCopy().mapTo(mutableListOf()) { - val superTypeRef = transformer.transformTypeRef(it, scope).single + val superTypeRef = transformer.transformTypeRef(it, scope) val typeParameterType = superTypeRef.coneTypeSafe() when { typeParameterType != null -> @@ -334,7 +334,7 @@ private class FirSupertypeResolverVisitor( resolveSpecificClassLikeSupertypes(typeAlias) { transformer, scope -> val resolvedTypeRef = - transformer.transformTypeRef(typeAlias.expandedTypeRef, scope).single as? FirResolvedTypeRef + transformer.transformTypeRef(typeAlias.expandedTypeRef, scope) as? FirResolvedTypeRef ?: return@resolveSpecificClassLikeSupertypes listOf( createErrorTypeRef( typeAlias.expandedTypeRef, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt index c46a0dcd225..39bccda4581 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt @@ -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.buildTypeProjectionWithVariance 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.compose import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability @@ -346,11 +344,11 @@ class FirSyntheticCallGenerator( } private object UpdateReference : FirTransformer() { - override fun transformElement(element: E, data: FirNamedReferenceWithCandidate): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: FirNamedReferenceWithCandidate): E { + return element } - override fun transformReference(reference: FirReference, data: FirNamedReferenceWithCandidate): CompositeTransformResult { - return data.compose() + override fun transformReference(reference: FirReference, data: FirNamedReferenceWithCandidate): FirReference { + return data } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt index 5abd01cf473..bd58eeb6bc7 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt @@ -16,8 +16,6 @@ import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.createImportingScopes import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef -import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult -import org.jetbrains.kotlin.fir.visitors.compose class FirTypeResolveProcessor( session: FirSession, @@ -33,7 +31,7 @@ fun > F.runTypeResolvePhaseForLocalClass( ): F { val transformer = FirTypeResolveTransformer(session, scopeSession, currentScopeList) - return this.transform(transformer, null).single + return this.transform(transformer, null) } class FirTypeResolveTransformer( @@ -52,7 +50,7 @@ class FirTypeResolveTransformer( private val typeResolverTransformer: FirSpecificTypeResolverTransformer = FirSpecificTypeResolverTransformer(session) private var currentFile: FirFile? = null - override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { + override fun transformFile(file: FirFile, data: Nothing?): FirFile { checkSessionConsistency(file) currentFile = file return withScopeCleanup { @@ -61,7 +59,7 @@ class FirTypeResolveTransformer( } } - override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult { + override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement { withScopeCleanup { regularClass.addTypeParametersScope() regularClass.typeParameters.forEach { @@ -73,33 +71,33 @@ class FirTypeResolveTransformer( return resolveNestedClassesSupertypes(regularClass, data) } - override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): CompositeTransformResult { + override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): FirStatement { return resolveNestedClassesSupertypes(anonymousObject, data) } - override fun transformConstructor(constructor: FirConstructor, data: Nothing?): CompositeTransformResult { + override fun transformConstructor(constructor: FirConstructor, data: Nothing?): FirDeclaration { return withScopeCleanup { constructor.addTypeParametersScope() transformDeclaration(constructor, data) } } - override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult { + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): FirDeclaration { return withScopeCleanup { typeAlias.addTypeParametersScope() transformDeclaration(typeAlias, data) } } - override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): CompositeTransformResult { + override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): FirDeclaration { enumEntry.replaceResolvePhase(FirResolvePhase.TYPES) enumEntry.transformReturnTypeRef(this, data) enumEntry.transformTypeParameters(this, data) enumEntry.transformAnnotations(this, data) - return enumEntry.compose() + return enumEntry } - override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: Nothing?): FirDeclaration { return withScopeCleanup { property.addTypeParametersScope() property.replaceResolvePhase(FirResolvePhase.TYPES) @@ -117,23 +115,23 @@ class FirTypeResolveTransformer( unboundCyclesInTypeParametersSupertypes(property) - property.compose() + property } } - override fun transformField(field: FirField, data: Nothing?): CompositeTransformResult { + override fun transformField(field: FirField, data: Nothing?): FirDeclaration { return withScopeCleanup { field.replaceResolvePhase(FirResolvePhase.TYPES) field.transformReturnTypeRef(this, data).transformAnnotations(this, data) - field.compose() + field } } - override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): CompositeTransformResult { + override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): FirDeclaration { return withScopeCleanup { simpleFunction.addTypeParametersScope() 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 { + override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?): FirTypeRef { if (implicitTypeRef is FirImplicitBuiltinTypeRef) return transformTypeRef(implicitTypeRef, data) - return implicitTypeRef.compose() + return implicitTypeRef } - override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult { + override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): FirResolvedTypeRef { return typeResolverTransformer.withFile(currentFile) { typeRef.transform(typeResolverTransformer, towerScope) } } - override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult { + override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): FirStatement { valueParameter.transformReturnTypeRef(this, data) valueParameter.transformAnnotations(this, data) valueParameter.transformVarargTypeToArrayType() - return valueParameter.compose() + return valueParameter } - override fun transformBlock(block: FirBlock, data: Nothing?): CompositeTransformResult { - return block.compose() + override fun transformBlock(block: FirBlock, data: Nothing?): FirStatement { + return block } override fun transformDelegatedConstructorCall( delegatedConstructorCall: FirDelegatedConstructorCall, data: Nothing? - ): CompositeTransformResult { + ): FirStatement { delegatedConstructorCall.replaceConstructedTypeRef( - delegatedConstructorCall.constructedTypeRef.transform(this, data).single + delegatedConstructorCall.constructedTypeRef.transform(this, data) ) delegatedConstructorCall.transformCalleeReference(this, data) - return delegatedConstructorCall.compose() + return delegatedConstructorCall } - override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?): CompositeTransformResult { + override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?): FirStatement { annotationCall.transformAnnotationTypeRef(this, data) - return annotationCall.compose() + return annotationCall } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt index 74a366bc4ea..21a93415023 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt @@ -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.FirVariableSymbol 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.FirVisitor -import org.jetbrains.kotlin.fir.visitors.compose class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyResolveComponents) : FirTransformer() { companion object { @@ -37,13 +35,13 @@ class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyRe ) } - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { + override fun transformElement(element: E, data: Nothing?): E { throw IllegalArgumentException("Should not be there") } - override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Nothing?): CompositeTransformResult { + override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Nothing?): FirStatement { processExhaustivenessCheck(whenExpression) - return whenExpression.compose() + return whenExpression } @OptIn(ExperimentalStdlibApi::class) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt index bb2424c0f81..24670c8ef8b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt @@ -15,9 +15,7 @@ import org.jetbrains.kotlin.fir.types.ConeIntegerLiteralType import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.coneTypeSafe 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.compose import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.types.ConstantValueKind @@ -26,20 +24,20 @@ fun FirExpression.approximateIfIsIntegerConst(expectedType: ConeKotlinType? = nu } private object IntegerLiteralTypeApproximationTransformer : FirTransformer() { - override fun transformElement(element: E, data: ConeKotlinType?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: ConeKotlinType?): E { + return element } override fun transformConstExpression( constExpression: FirConstExpression, data: ConeKotlinType? - ): CompositeTransformResult { - val type = constExpression.resultType.coneTypeSafe() ?: return constExpression.compose() + ): FirStatement { + val type = constExpression.resultType.coneTypeSafe() ?: return constExpression val approximatedType = type.getApproximatedType(data) constExpression.resultType = constExpression.resultType.resolvedTypeFromPrototype(approximatedType) @Suppress("UNCHECKED_CAST") val kind = approximatedType.toConstKind() as ConstantValueKind constExpression.replaceKind(kind) - return constExpression.compose() + return constExpression } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt index fbfc03a2818..b1118be0b0c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt @@ -14,54 +14,52 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.declarations.isInline import org.jetbrains.kotlin.fir.expressions.* 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.compose object InvocationKindTransformer : FirTransformer() { private object ArgumentsTransformer : FirTransformer, EventOccurrencesRange?>>() { - override fun transformElement(element: E, data: Pair, EventOccurrencesRange?>): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Pair, EventOccurrencesRange?>): E { + return element } override fun transformAnonymousFunction( anonymousFunction: FirAnonymousFunction, data: Pair, EventOccurrencesRange?> - ): CompositeTransformResult { + ): FirStatement { val kind = data.second ?: data.first[anonymousFunction] if (kind != null) { anonymousFunction.replaceInvocationKind(kind) } - return anonymousFunction.compose() + return anonymousFunction } override fun transformLambdaArgumentExpression( lambdaArgumentExpression: FirLambdaArgumentExpression, data: Pair, EventOccurrencesRange?> - ): CompositeTransformResult { + ): FirStatement { return data.first[lambdaArgumentExpression]?.let { - (lambdaArgumentExpression.transformChildren(this, data.first to it) as FirStatement).compose() - } ?: lambdaArgumentExpression.compose() + (lambdaArgumentExpression.transformChildren(this, data.first to it) as FirStatement) + } ?: lambdaArgumentExpression } override fun transformNamedArgumentExpression( namedArgumentExpression: FirNamedArgumentExpression, data: Pair, EventOccurrencesRange?> - ): CompositeTransformResult { + ): FirStatement { return data.first[namedArgumentExpression]?.let { - (namedArgumentExpression.transformChildren(this, data.first to it) as FirStatement).compose() - } ?: namedArgumentExpression.compose() + (namedArgumentExpression.transformChildren(this, data.first to it) as FirStatement) + } ?: namedArgumentExpression } } - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformFunctionCall(functionCall: FirFunctionCall, data: Nothing?): CompositeTransformResult { - val calleeReference = functionCall.calleeReference as? FirNamedReferenceWithCandidate ?: return functionCall.compose() - val argumentMapping = calleeReference.candidate.argumentMapping ?: return functionCall.compose() - val function = calleeReference.candidateSymbol.fir as? FirSimpleFunction ?: return functionCall.compose() + override fun transformFunctionCall(functionCall: FirFunctionCall, data: Nothing?): FirStatement { + val calleeReference = functionCall.calleeReference as? FirNamedReferenceWithCandidate ?: return functionCall + val argumentMapping = calleeReference.candidate.argumentMapping ?: return functionCall + val function = calleeReference.candidateSymbol.fir as? FirSimpleFunction ?: return functionCall val callsEffects = function.contractDescription.effects ?.map { it.effect } @@ -69,7 +67,7 @@ object InvocationKindTransformer : FirTransformer() { val isInline = function.isInline if (callsEffects.isEmpty() && !isInline) { - return functionCall.compose() + return functionCall } val reversedArgumentMapping = argumentMapping.entries.map { (argument, parameter) -> @@ -89,9 +87,9 @@ object InvocationKindTransformer : FirTransformer() { } } if (invocationKindMapping.isEmpty()) { - return functionCall.compose() + return functionCall } functionCall.argumentList.transformArguments(ArgumentsTransformer, invocationKindMapping to null) - return functionCall.compose() + return functionCall } } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt index 2ee9a1b9312..bcc4a9566ee 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ResolvePhaseUtils.kt @@ -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.contracts.FirContractResolveProcessor 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.compose fun FirResolvePhase.createCompilerProcessorByPhase( session: FirSession, @@ -48,8 +46,8 @@ class FirDummyTransformerBasedProcessor( get() = DummyTransformer private object DummyTransformer : FirTransformer() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt index b4c4bd395bc..c5718751af9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt @@ -14,83 +14,81 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.references.* import org.jetbrains.kotlin.fir.types.* 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.FirTransformer -import org.jetbrains.kotlin.fir.visitors.compose internal object StoreType : FirDefaultTransformer() { - override fun transformElement(element: E, data: FirTypeRef): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: FirTypeRef): E { + return element } - override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): CompositeTransformResult { - return data.compose() + override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): FirTypeRef { + return data } } internal object TransformImplicitType : FirDefaultTransformer() { - override fun transformElement(element: E, data: FirTypeRef): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: FirTypeRef): E { + return element } override fun transformImplicitTypeRef( implicitTypeRef: FirImplicitTypeRef, data: FirTypeRef - ): CompositeTransformResult { - return data.compose() + ): FirTypeRef { + return data } } internal object StoreNameReference : FirDefaultTransformer() { - override fun transformElement(element: E, data: FirNamedReference): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: FirNamedReference): E { + return element } override fun transformNamedReference( namedReference: FirNamedReference, data: FirNamedReference - ): CompositeTransformResult { - return data.compose() + ): FirNamedReference { + return data } - override fun transformThisReference(thisReference: FirThisReference, data: FirNamedReference): CompositeTransformResult { - return data.compose() + override fun transformThisReference(thisReference: FirThisReference, data: FirNamedReference): FirReference { + return data } override fun transformSuperReference( superReference: FirSuperReference, data: FirNamedReference - ): CompositeTransformResult { - return data.compose() + ): FirReference { + return data } } internal object StoreCalleeReference : FirTransformer() { - override fun transformElement(element: E, data: FirNamedReference): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: FirNamedReference): E { + return element } override fun transformNamedReference( namedReference: FirNamedReference, data: FirNamedReference - ): CompositeTransformResult { - return data.compose() + ): FirNamedReference { + return data } override fun transformResolvedNamedReference( resolvedNamedReference: FirResolvedNamedReference, data: FirNamedReference - ): CompositeTransformResult { - return data.compose() + ): FirNamedReference { + return data } } internal object StoreReceiver : FirTransformer() { - override fun transformElement(element: E, data: FirExpression): CompositeTransformResult { + override fun transformElement(element: E, data: FirExpression): E { @Suppress("UNCHECKED_CAST") - return (data as E).compose() + return (data as E) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt index d1ac6a381b8..61174068c08 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt @@ -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.FirResolvedTypeRef 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.compose open class FirBodyResolveTransformer( session: FirSession, @@ -46,35 +44,35 @@ open class FirBodyResolveTransformer( protected open val declarationsTransformer = FirDeclarationsResolveTransformer(this) private val controlFlowStatementsTransformer = FirControlFlowStatementsResolveTransformer(this) - override fun transformFile(file: FirFile, data: ResolutionMode): CompositeTransformResult { + override fun transformFile(file: FirFile, data: ResolutionMode): FirFile { checkSessionConsistency(file) return context.withFile(file, components) { onBeforeFileContentResolution(file) file.replaceResolvePhase(transformerPhase) @Suppress("UNCHECKED_CAST") - transformDeclarationContent(file, data) as CompositeTransformResult + transformDeclarationContent(file, data) as FirFile } } - override fun transformElement(element: E, data: ResolutionMode): CompositeTransformResult { + override fun transformElement(element: E, data: ResolutionMode): E { @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 { + override fun transformTypeRef(typeRef: FirTypeRef, data: ResolutionMode): FirResolvedTypeRef { if (typeRef is FirResolvedTypeRef) { - return typeRef.compose() + return typeRef } return typeResolverTransformer.withFile(context.file) { transformTypeRef(typeRef, FirCompositeScope(components.createCurrentScopeList())) } } - override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: ResolutionMode): CompositeTransformResult { + override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: ResolutionMode): FirTypeRef { if (data !is ResolutionMode.WithExpectedType) - return implicitTypeRef.compose() - return data.expectedTypeRef.compose() + return implicitTypeRef + return data.expectedTypeRef } open fun onBeforeFileContentResolution(file: FirFile) {} @@ -85,282 +83,282 @@ open class FirBodyResolveTransformer( // ------------------------------------- Expressions ------------------------------------- - override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult { + override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement { return expressionsTransformer.transformExpression(expression, data) } override fun transformWrappedArgumentExpression( wrappedArgumentExpression: FirWrappedArgumentExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return transformElement(wrappedArgumentExpression, data) } override fun transformQualifiedAccessExpression( qualifiedAccessExpression: FirQualifiedAccessExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformQualifiedAccessExpression(qualifiedAccessExpression, data) } - override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult { + override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): FirStatement { return expressionsTransformer.transformFunctionCall(functionCall, data) } override fun transformCallableReferenceAccess( callableReferenceAccess: FirCallableReferenceAccess, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformCallableReferenceAccess(callableReferenceAccess, data) } - override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult { + override fun transformBlock(block: FirBlock, data: ResolutionMode): FirStatement { return expressionsTransformer.transformBlock(block, data) } override fun transformThisReceiverExpression( thisReceiverExpression: FirThisReceiverExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformThisReceiverExpression(thisReceiverExpression, data) } override fun transformComparisonExpression( comparisonExpression: FirComparisonExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformComparisonExpression(comparisonExpression, data) } override fun transformTypeOperatorCall( typeOperatorCall: FirTypeOperatorCall, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformTypeOperatorCall(typeOperatorCall, data) } override fun transformAssignmentOperatorStatement( assignmentOperatorStatement: FirAssignmentOperatorStatement, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformAssignmentOperatorStatement(assignmentOperatorStatement, data) } override fun transformEqualityOperatorCall( equalityOperatorCall: FirEqualityOperatorCall, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformEqualityOperatorCall(equalityOperatorCall, data) } override fun transformCheckNotNullCall( checkNotNullCall: FirCheckNotNullCall, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformCheckNotNullCall(checkNotNullCall, data) } override fun transformBinaryLogicExpression( binaryLogicExpression: FirBinaryLogicExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformBinaryLogicExpression(binaryLogicExpression, data) } override fun transformVariableAssignment( variableAssignment: FirVariableAssignment, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformVariableAssignment(variableAssignment, data) } - override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): CompositeTransformResult { + override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): FirStatement { return expressionsTransformer.transformGetClassCall(getClassCall, data) } override fun transformWrappedDelegateExpression( wrappedDelegateExpression: FirWrappedDelegateExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return declarationsTransformer.transformWrappedDelegateExpression(wrappedDelegateExpression, data) } override fun transformConstExpression( constExpression: FirConstExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformConstExpression(constExpression, data) } - override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult { + override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement { return expressionsTransformer.transformAnnotationCall(annotationCall, data) } override fun transformDelegatedConstructorCall( delegatedConstructorCall: FirDelegatedConstructorCall, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformDelegatedConstructorCall(delegatedConstructorCall, data) } override fun transformAugmentedArraySetCall( augmentedArraySetCall: FirAugmentedArraySetCall, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformAugmentedArraySetCall(augmentedArraySetCall, data) } override fun transformSafeCallExpression( safeCallExpression: FirSafeCallExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformSafeCallExpression(safeCallExpression, data) } override fun transformCheckedSafeCallSubject( checkedSafeCallSubject: FirCheckedSafeCallSubject, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return expressionsTransformer.transformCheckedSafeCallSubject(checkedSafeCallSubject, data) } // ------------------------------------- Declarations ------------------------------------- - override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult { + override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration { return declarationsTransformer.transformDeclaration(declaration, data) } open fun transformDeclarationContent( declaration: FirDeclaration, data: ResolutionMode - ): CompositeTransformResult { + ): FirDeclaration { return transformElement(declaration, data) } override fun transformDeclarationStatus( declarationStatus: FirDeclarationStatus, data: ResolutionMode - ): CompositeTransformResult { + ): FirDeclarationStatus { return declarationsTransformer.transformDeclarationStatus(declarationStatus, data) } - override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): CompositeTransformResult { + override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirDeclaration { return declarationsTransformer.transformEnumEntry(enumEntry, data) } - override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty { return declarationsTransformer.transformProperty(property, data) } - override fun transformField(field: FirField, data: ResolutionMode): CompositeTransformResult { + override fun transformField(field: FirField, data: ResolutionMode): FirDeclaration { return declarationsTransformer.transformField(field, data) } - override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult { + override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement { return declarationsTransformer.transformRegularClass(regularClass, data) } override fun transformAnonymousObject( anonymousObject: FirAnonymousObject, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return declarationsTransformer.transformAnonymousObject(anonymousObject, data) } override fun transformSimpleFunction( simpleFunction: FirSimpleFunction, data: ResolutionMode - ): CompositeTransformResult { + ): FirSimpleFunction { return declarationsTransformer.transformSimpleFunction(simpleFunction, data) } override fun > transformFunction( function: FirFunction, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return declarationsTransformer.transformFunction(function, data) } - override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult { + override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration { return declarationsTransformer.transformConstructor(constructor, data) } override fun transformAnonymousInitializer( anonymousInitializer: FirAnonymousInitializer, data: ResolutionMode - ): CompositeTransformResult { + ): FirDeclaration { return declarationsTransformer.transformAnonymousInitializer(anonymousInitializer, data) } override fun transformAnonymousFunction( anonymousFunction: FirAnonymousFunction, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return declarationsTransformer.transformAnonymousFunction(anonymousFunction, data) } - override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult { + override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement { return declarationsTransformer.transformValueParameter(valueParameter, data) } - override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): CompositeTransformResult { + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirDeclaration { return declarationsTransformer.transformTypeAlias(typeAlias, data) } // ------------------------------------- Control flow statements ------------------------------------- - override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): CompositeTransformResult { + override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): FirStatement { return controlFlowStatementsTransformer.transformWhileLoop(whileLoop, data) } - override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): CompositeTransformResult { + override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): FirStatement { return controlFlowStatementsTransformer.transformDoWhileLoop(doWhileLoop, data) } - override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): CompositeTransformResult { + override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): FirStatement { return controlFlowStatementsTransformer.transformWhenExpression(whenExpression, data) } - override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): CompositeTransformResult { + override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): FirWhenBranch { return controlFlowStatementsTransformer.transformWhenBranch(whenBranch, data) } override fun transformWhenSubjectExpression( whenSubjectExpression: FirWhenSubjectExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return controlFlowStatementsTransformer.transformWhenSubjectExpression(whenSubjectExpression, data) } - override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): CompositeTransformResult { + override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): FirStatement { return controlFlowStatementsTransformer.transformTryExpression(tryExpression, data) } - override fun transformCatch(catch: FirCatch, data: ResolutionMode): CompositeTransformResult { + override fun transformCatch(catch: FirCatch, data: ResolutionMode): FirCatch { return controlFlowStatementsTransformer.transformCatch(catch, data) } - override fun transformJump(jump: FirJump, data: ResolutionMode): CompositeTransformResult { + override fun transformJump(jump: FirJump, data: ResolutionMode): FirStatement { return controlFlowStatementsTransformer.transformJump(jump, data) } override fun transformReturnExpression( returnExpression: FirReturnExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return controlFlowStatementsTransformer.transformReturnExpression(returnExpression, data) } override fun transformThrowExpression( throwExpression: FirThrowExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return controlFlowStatementsTransformer.transformThrowExpression(throwExpression, data) } override fun transformElvisExpression( elvisExpression: FirElvisExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return controlFlowStatementsTransformer.transformElvisExpression(elvisExpression, data) } @@ -368,6 +366,6 @@ open class FirBodyResolveTransformer( fun FirElement.visitNoTransform(transformer: FirTransformer, data: D) { val result = this.transform(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()}`" } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformerAdapters.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformerAdapters.kt index 9110b61aea7..9157101be02 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformerAdapters.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformerAdapters.kt @@ -13,9 +13,7 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor 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.compose @OptIn(AdapterForResolveProcessor::class) class FirBodyResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) { @@ -31,11 +29,11 @@ class FirBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeS scopeSession = scopeSession ) - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { + override fun transformFile(file: FirFile, data: Nothing?): FirFile { return file.transform(transformer, ResolutionMode.ContextIndependent) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt index 11758b93a5b..e74e2070711 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt @@ -19,8 +19,6 @@ import org.jetbrains.kotlin.fir.resolve.withExpectedType import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype import org.jetbrains.kotlin.fir.types.* 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 class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTransformer) : @@ -32,15 +30,15 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran // ------------------------------- Loops ------------------------------- - override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): CompositeTransformResult { + override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): FirStatement { val context = ResolutionMode.ContextIndependent return whileLoop.also(dataFlowAnalyzer::enterWhileLoop) .transformCondition(transformer, context).also(dataFlowAnalyzer::exitWhileLoopCondition) .transformBlock(transformer, context).also(dataFlowAnalyzer::exitWhileLoop) - .transformOtherChildren(transformer, context).compose() + .transformOtherChildren(transformer, context) } - override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): CompositeTransformResult { + override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): FirStatement { // Do-while has a specific scope structure (its block and condition effectively share the scope) return context.forBlock { val context = ResolutionMode.ContextIndependent @@ -50,15 +48,15 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran } .also(dataFlowAnalyzer::enterDoWhileLoopCondition).transformCondition(transformer, context) .also(dataFlowAnalyzer::exitDoWhileLoop) - .transformOtherChildren(transformer, context).compose() + .transformOtherChildren(transformer, context) } } // ------------------------------- When expressions ------------------------------- - override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): CompositeTransformResult { + override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): FirStatement { if (whenExpression.calleeReference is FirResolvedNamedReference && whenExpression.resultType !is FirImplicitTypeRef) { - return whenExpression.compose() + return whenExpression } whenExpression.annotations.forEach { it.accept(this, data) } dataFlowAnalyzer.enterWhenExpression(whenExpression) @@ -81,7 +79,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran whenExpression.resultType = buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Can't resolve when expression", DiagnosticKind.InferenceError) } - return@with whenExpression.compose() + return@with whenExpression } val expectedTypeRef = data.expectedType @@ -92,7 +90,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran whenExpression = whenExpression.transformSingle(whenExhaustivenessTransformer, null) dataFlowAnalyzer.exitWhenExpression(whenExpression) 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 } - override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): CompositeTransformResult { + override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): FirWhenBranch { return whenBranch.also { dataFlowAnalyzer.enterWhenBranchCondition(whenBranch) } .transformCondition(transformer, withExpectedType(session.builtinTypes.booleanType)) .also { dataFlowAnalyzer.exitWhenBranchCondition(it) } .transformResult(transformer, data) .also { dataFlowAnalyzer.exitWhenBranchResult(it) } - .compose() + } override fun transformWhenSubjectExpression( whenSubjectExpression: FirWhenSubjectExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { val parentWhen = whenSubjectExpression.whenRef.value val subjectType = parentWhen.subject?.resultType ?: parentWhen.subjectVariable?.returnTypeRef if (subjectType != null) { whenSubjectExpression.resultType = subjectType } - return whenSubjectExpression.compose() + return whenSubjectExpression } // ------------------------------- Try/catch expressions ------------------------------- - override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): CompositeTransformResult { + override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): FirStatement { if (tryExpression.calleeReference is FirResolvedNamedReference && tryExpression.resultType !is FirImplicitTypeRef) { - return tryExpression.compose() + return tryExpression } tryExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent) @@ -168,30 +166,30 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran result } dataFlowAnalyzer.exitTryExpression(callCompleted) - return result.compose() + return result } - override fun transformCatch(catch: FirCatch, data: ResolutionMode): CompositeTransformResult { + override fun transformCatch(catch: FirCatch, data: ResolutionMode): FirCatch { dataFlowAnalyzer.enterCatchClause(catch) catch.parameter.transformReturnTypeRef(transformer, ResolutionMode.ContextIndependent) return context.forBlock { catch.transformParameter(transformer, ResolutionMode.ContextIndependent) catch.transformBlock(transformer, ResolutionMode.ContextDependent) - }.also { dataFlowAnalyzer.exitCatchClause(it) }.compose() + }.also { dataFlowAnalyzer.exitCatchClause(it) } } // ------------------------------- Jumps ------------------------------- - override fun transformJump(jump: FirJump, data: ResolutionMode): CompositeTransformResult { - val result = transformer.transformExpression(jump, data).single + override fun transformJump(jump: FirJump, data: ResolutionMode): FirStatement { + val result = transformer.transformExpression(jump, data) dataFlowAnalyzer.exitJump(jump) - return result.compose() + return result } override fun transformReturnExpression( returnExpression: FirReturnExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { val labeledElement = returnExpression.target.labeledElement val expectedTypeRef = labeledElement.returnTypeRef @Suppress("IntroduceWhenSubject") @@ -210,9 +208,9 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran override fun transformThrowExpression( throwExpression: FirThrowExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { 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( elvisExpression: FirElvisExpression, data: ResolutionMode - ): CompositeTransformResult { - if (elvisExpression.calleeReference is FirResolvedNamedReference) return elvisExpression.compose() + ): FirStatement { + if (elvisExpression.calleeReference is FirResolvedNamedReference) return elvisExpression elvisExpression.transformAnnotations(transformer, data) val expectedType = data.expectedType?.coneTypeSafe() @@ -242,6 +240,6 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran } dataFlowAnalyzer.exitElvis(elvisExpression) - return result.compose() + return result } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index b32095d77e9..cb2851c9745 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt @@ -63,7 +63,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor private fun transformDeclarationContent( declaration: FirDeclaration, data: ResolutionMode - ): CompositeTransformResult { + ): FirDeclaration { transformer.onBeforeDeclarationContentResolve(declaration) transformer.replaceDeclarationResolvePhaseIfNeeded(declaration, transformerPhase) return transformer.transformDeclarationContent(declaration, data) @@ -72,8 +72,8 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor override fun transformDeclarationStatus( declarationStatus: FirDeclarationStatus, data: ResolutionMode - ): CompositeTransformResult { - return ((data as? ResolutionMode.WithStatus)?.status ?: declarationStatus).compose() + ): FirDeclarationStatus { + return ((data as? ResolutionMode.WithStatus)?.status ?: declarationStatus) } private fun prepareSignatureForBodyResolve(callableMember: FirCallableMemberDeclaration<*>) { @@ -100,15 +100,15 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor } } - override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): CompositeTransformResult { - if (enumEntry.resolvePhase == transformerPhase) return enumEntry.compose() + override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirDeclaration { + if (enumEntry.resolvePhase == transformerPhase) return enumEntry transformer.replaceDeclarationResolvePhaseIfNeeded(enumEntry, transformerPhase) return context.forEnumEntry { - (enumEntry.transformChildren(this, data) as FirEnumEntry).compose() + (enumEntry.transformChildren(this, data) as FirEnumEntry) } } - override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty { require(property !is FirSyntheticProperty) { "Synthetic properties should not be processed by body transfromers" } if (property.isLocal) { @@ -120,10 +120,10 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor } val returnTypeRef = property.returnTypeRef - if (returnTypeRef !is FirImplicitTypeRef && implicitTypeOnly) return property.compose() - if (property.resolvePhase == transformerPhase) return property.compose() + if (returnTypeRef !is FirImplicitTypeRef && implicitTypeOnly) return property + if (property.resolvePhase == transformerPhase) return property if (property.resolvePhase == FirResolvePhase.BODY_RESOLVE || property.resolvePhase == transformerPhase) { - return property.compose() + return property } dataFlowAnalyzer.enterProperty(property) @@ -151,15 +151,15 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor dataFlowAnalyzer.exitProperty(property)?.let { property.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(it)) } - property.compose() + property } } - override fun transformField(field: FirField, data: ResolutionMode): CompositeTransformResult { + override fun transformField(field: FirField, data: ResolutionMode): FirDeclaration { val returnTypeRef = field.returnTypeRef - if (implicitTypeOnly) return field.compose() + if (implicitTypeOnly) return field if (field.resolvePhase == FirResolvePhase.BODY_RESOLVE || field.resolvePhase == transformerPhase) { - return field.compose() + return field } dataFlowAnalyzer.enterField(field) return withFullBodyResolve { @@ -171,7 +171,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor } transformer.replaceDeclarationResolvePhaseIfNeeded(field, transformerPhase) dataFlowAnalyzer.exitField(field) - field.compose() + field } } @@ -236,16 +236,16 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor override fun transformWrappedDelegateExpression( wrappedDelegateExpression: FirWrappedDelegateExpression, data: ResolutionMode, - ): CompositeTransformResult { + ): FirStatement { dataFlowAnalyzer.enterDelegateExpression() try { val delegateProvider = wrappedDelegateExpression.delegateProvider.transformSingle(transformer, data) when (val calleeReference = (delegateProvider as FirResolvable).calleeReference) { - is FirResolvedNamedReference -> return delegateProvider.compose() + is FirResolvedNamedReference -> return delegateProvider is FirNamedReferenceWithCandidate -> { val candidate = calleeReference.candidate if (!candidate.system.hasContradiction) { - return delegateProvider.compose() + return delegateProvider } } } @@ -254,13 +254,13 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor return wrappedDelegateExpression.expression .transformSingle(transformer, data) .approximateIfIsIntegerConst() - .compose() + } finally { dataFlowAnalyzer.exitDelegateExpression() } } - private fun transformLocalVariable(variable: FirProperty): CompositeTransformResult { + private fun transformLocalVariable(variable: FirProperty): FirProperty { assert(variable.isLocal) variable.transformDelegate(transformer, ResolutionMode.ContextDependentDelegate) val delegate = variable.delegate @@ -281,7 +281,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor context.storeVariable(variable) transformer.replaceDeclarationResolvePhaseIfNeeded(variable, transformerPhase) dataFlowAnalyzer.exitLocalVariableDeclaration(variable) - return variable.compose() + return variable } private fun FirProperty.transformChildrenWithoutAccessors(returnTypeRef: FirTypeRef): FirProperty { @@ -349,29 +349,29 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor ) } - override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult { + override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement { if (regularClass.isLocal && regularClass !in context.targetedLocalClasses) { - return regularClass.runAllPhasesForLocalClass(transformer, components, data).compose() + return regularClass.runAllPhasesForLocalClass(transformer, components, data) } doTransformTypeParameters(regularClass) return doTransformRegularClass(regularClass, data) } - override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): CompositeTransformResult { + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirDeclaration { if (typeAlias.isLocal && typeAlias !in context.targetedLocalClasses) { - return typeAlias.runAllPhasesForLocalClass(transformer, components, data).compose() + return typeAlias.runAllPhasesForLocalClass(transformer, components, data) } doTransformTypeParameters(typeAlias) typeAlias.transformAnnotations(transformer, data) typeAlias.transformExpandedTypeRef(transformer, data) - return typeAlias.compose() + return typeAlias } private fun doTransformRegularClass( regularClass: FirRegularClass, data: ResolutionMode - ): CompositeTransformResult.Single { + ): FirRegularClass { val notAnalyzed = regularClass.resolvePhase < transformerPhase if (notAnalyzed) { @@ -379,7 +379,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor } val result = context.withRegularClass(regularClass, components) { - transformDeclarationContent(regularClass, data).single as FirRegularClass + transformDeclarationContent(regularClass, data) as FirRegularClass } if (notAnalyzed) { @@ -391,16 +391,15 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor } } - (@Suppress("UNCHECKED_CAST") - return result.compose()) + return result } override fun transformAnonymousObject( anonymousObject: FirAnonymousObject, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { if (anonymousObject !in context.targetedLocalClasses) { - return anonymousObject.runAllPhasesForLocalClass(transformer, components, data).compose() + return anonymousObject.runAllPhasesForLocalClass(transformer, components, data) } dataFlowAnalyzer.enterClass() if (anonymousObject.typeRef !is FirResolvedTypeRef) { @@ -410,7 +409,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor } } val result = context.withAnonymousObject(anonymousObject, components) { - transformDeclarationContent(anonymousObject, data).single as FirAnonymousObject + transformDeclarationContent(anonymousObject, data) as FirAnonymousObject } if (!implicitTypeOnly && result.controlFlowGraphReference == null) { val graph = dataFlowAnalyzer.exitAnonymousObject(result) @@ -418,7 +417,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor } else { dataFlowAnalyzer.exitClass() } - return result.compose() + return result } private fun transformAnonymousFunctionWithLambdaResolution( @@ -426,7 +425,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor ): FirAnonymousFunction { val expectedReturnType = 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 if (result.returnTypeRef is FirImplicitTypeRef && body != null) { // 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( simpleFunction: FirSimpleFunction, data: ResolutionMode - ): CompositeTransformResult { + ): FirSimpleFunction { if (simpleFunction.resolvePhase == FirResolvePhase.BODY_RESOLVE || simpleFunction.resolvePhase == transformerPhase) { - return simpleFunction.compose() + return simpleFunction } val returnTypeRef = simpleFunction.returnTypeRef if ((returnTypeRef !is FirImplicitTypeRef) && implicitTypeOnly) { - return simpleFunction.compose() + return simpleFunction } doTransformTypeParameters(simpleFunction) @@ -484,9 +483,9 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor private fun > transformFunctionWithGivenSignature( function: F, resolutionMode: ResolutionMode, - ): CompositeTransformResult { + ): F { @Suppress("UNCHECKED_CAST") - val result = transformFunction(function, resolutionMode).single as F + val result = transformFunction(function, resolutionMode) as F val body = result.body if (result.returnTypeRef is FirImplicitTypeRef) { @@ -511,13 +510,13 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor } } - return result.compose() + return result } override fun > transformFunction( function: FirFunction, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { val functionIsNotAnalyzed = transformerPhase != function.resolvePhase if (functionIsNotAnalyzed) { dataFlowAnalyzer.enterFunction(function) @@ -525,15 +524,15 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor @Suppress("UNCHECKED_CAST") return transformDeclarationContent(function, data).also { if (functionIsNotAnalyzed) { - val result = it.single as FirFunction<*> + val result = it as FirFunction<*> val controlFlowGraphReference = dataFlowAnalyzer.exitFunction(result) result.replaceControlFlowGraphReference(controlFlowGraphReference) } - } as CompositeTransformResult + } as FirStatement } - override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult { - if (implicitTypeOnly) return constructor.compose() + override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration { + if (implicitTypeOnly) return constructor val container = context.containerIfAny as? FirRegularClass if (constructor.isPrimary && container?.classKind == ClassKind.ANNOTATION_CLASS) { return withFirArrayOfCallTransformer { @@ -545,7 +544,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor return doTransformConstructor(constructor, data) } - private fun doTransformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult { + private fun doTransformConstructor(constructor: FirConstructor, data: ResolutionMode): FirConstructor { val owningClass = context.containerIfAny as? FirRegularClass transformer.replaceDeclarationResolvePhaseIfNeeded(constructor, transformerPhase) @@ -568,25 +567,25 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor val controlFlowGraphReference = dataFlowAnalyzer.exitFunction(constructor) constructor.replaceControlFlowGraphReference(controlFlowGraphReference) - return constructor.compose() + return constructor } override fun transformAnonymousInitializer( anonymousInitializer: FirAnonymousInitializer, data: ResolutionMode - ): CompositeTransformResult { - if (implicitTypeOnly) return anonymousInitializer.compose() + ): FirDeclaration { + if (implicitTypeOnly) return anonymousInitializer dataFlowAnalyzer.enterInitBlock(anonymousInitializer) return context.withAnonymousInitializer(anonymousInitializer) { val result = - transformDeclarationContent(anonymousInitializer, ResolutionMode.ContextIndependent).single as FirAnonymousInitializer + transformDeclarationContent(anonymousInitializer, ResolutionMode.ContextIndependent) as FirAnonymousInitializer val graph = dataFlowAnalyzer.exitInitBlock(result) result.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(graph)) - result.compose() + result } } - override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult { + override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement { if (valueParameter.returnTypeRef is FirImplicitTypeRef) { transformer.replaceDeclarationResolvePhaseIfNeeded(valueParameter, transformerPhase) valueParameter.replaceReturnTypeRef( @@ -595,7 +594,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor ) ) return context.withValueParameter(valueParameter) { - valueParameter.compose() + valueParameter } } @@ -604,20 +603,20 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor transformDeclarationContent( valueParameter, withExpectedType(valueParameter.returnTypeRef) - ).single as FirValueParameter + ) as FirValueParameter } dataFlowAnalyzer.exitValueParameter(result)?.let { graph -> result.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(graph)) } - return result.compose() + return result } override fun transformAnonymousFunction( anonymousFunction: FirAnonymousFunction, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { // Either ContextDependent, ContextIndependent or WithExpectedType could be here if (data !is ResolutionMode.LambdaResolution) { anonymousFunction.transformReturnTypeRef(transformer, ResolutionMode.ContextIndependent) @@ -628,12 +627,12 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor is ResolutionMode.ContextDependent, is ResolutionMode.ContextDependentDelegate -> { context.withAnonymousFunction(anonymousFunction, components, data) { dataFlowAnalyzer.visitPostponedAnonymousFunction(anonymousFunction) - anonymousFunction.addReturn().compose() + anonymousFunction.addReturn() } } is ResolutionMode.LambdaResolution -> { context.withAnonymousFunction(anonymousFunction, components, data) { - transformAnonymousFunctionWithLambdaResolution(anonymousFunction, data).addReturn().compose() + transformAnonymousFunctionWithLambdaResolution(anonymousFunction, data).addReturn() } } is ResolutionMode.WithExpectedType, is ResolutionMode.ContextIndependent -> { @@ -696,7 +695,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor lambda = lambda.transformValueParameters(ImplicitToErrorTypeTransformer, null) val bodyExpectedType = returnTypeRefFromResolvedAtom ?: expectedTypeRef 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 val writer = FirCallCompletionResultsWriterTransformer( @@ -740,7 +739,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor session.lookupTracker?.recordTypeResolveAsLookup(it, lambda.source, null) } ) - lambda.addReturn().compose() + lambda.addReturn() } is ResolutionMode.WithStatus -> { throw AssertionError("Should not be here in WithStatus mode") @@ -761,7 +760,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor if (lastStatement is FirExpression && !returnNothing) { body?.transformChildren( object : FirDefaultTransformer() { - override fun transformElement(element: E, data: FirExpression): CompositeTransformResult { + override fun transformElement(element: E, data: FirExpression): E { if (element == lastStatement) { val returnExpression = buildReturnExpression { source = element.source?.fakeElement(FirFakeSourceElementKind.ImplicitReturn) @@ -771,16 +770,16 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor } } @Suppress("UNCHECKED_CAST") - return (returnExpression as E).compose() + return (returnExpression as E) } - return element.compose() + return element } override fun transformReturnExpression( returnExpression: FirReturnExpression, data: FirExpression - ): CompositeTransformResult { - return returnExpression.compose() + ): FirStatement { + return returnExpression } }, buildUnitExpression() @@ -844,11 +843,11 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor } private object ImplicitToErrorTypeTransformer : FirTransformer() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult { + override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): FirStatement { if (valueParameter.returnTypeRef is FirImplicitTypeRef) { valueParameter.transformReturnTypeRef( StoreType, @@ -857,7 +856,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor ) ) } - return valueParameter.compose() + return valueParameter } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index 96336e760ea..cddb0fdef78 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -49,7 +49,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform components.callResolver.initTransformer(this) } - override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult { + override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement { if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) { val type = buildErrorTypeRef { source = expression.source @@ -60,13 +60,13 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform } expression.resultType = type } - return (expression.transformChildren(transformer, data) as FirStatement).compose() + return (expression.transformChildren(transformer, data) as FirStatement) } override fun transformQualifiedAccessExpression( qualifiedAccessExpression: FirQualifiedAccessExpression, data: ResolutionMode, - ): CompositeTransformResult { + ): FirStatement { qualifiedAccessExpression.transformAnnotations(this, data) qualifiedAccessExpression.transformTypeArguments(transformer, ResolutionMode.ContextIndependent) @@ -119,7 +119,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform // so candidate existence must be checked before calling completion if (transformedCallee is FirQualifiedAccessExpression && transformedCallee.candidate() != null) { if (!transformedCallee.isAcceptableResolvedQualifiedAccess()) { - return qualifiedAccessExpression.compose() + return qualifiedAccessExpression } callCompleter.completeCall(transformedCallee, data.expectedType).result } else { @@ -137,7 +137,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform dataFlowAnalyzer.exitResolvedQualifierNode(result) } } - return result.compose() + return result } fun transformSuperReceiver( @@ -232,7 +232,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform override fun transformSafeCallExpression( safeCallExpression: FirSafeCallExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { safeCallExpression.transformAnnotations(this, ResolutionMode.ContextIndependent) safeCallExpression.transformReceiver(this, ResolutionMode.ContextIndependent) @@ -248,17 +248,17 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform dataFlowAnalyzer.exitSafeCall(safeCallExpression) - return safeCallExpression.compose() + return safeCallExpression } override fun transformCheckedSafeCallSubject( checkedSafeCallSubject: FirCheckedSafeCallSubject, data: ResolutionMode - ): CompositeTransformResult { - return checkedSafeCallSubject.compose() + ): FirStatement { + return checkedSafeCallSubject } - override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult { + override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): FirStatement { if (functionCall.calleeReference is FirResolvedNamedReference && functionCall.resultType is FirImplicitTypeRef) { storeTypeFromCallee(functionCall) } @@ -268,9 +268,9 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform if (functionCall.calleeReference !is FirResolvedNamedReference) { 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() functionCall.transformAnnotations(transformer, data) functionCall.transformSingle(InvocationKindTransformer, null) @@ -294,18 +294,18 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform if (callCompleted) { if (enableArrayOfCallTransformation) { arrayOfCallTransformer.toArrayOfCall(completeInference)?.let { - return it.compose() + return it } } } - return completeInference.compose() + return completeInference } - override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult { + override fun transformBlock(block: FirBlock, data: ResolutionMode): FirStatement { context.forBlock { transformBlockInCurrentScope(block, data) } - return block.compose() + return block } internal fun transformBlockInCurrentScope(block: FirBlock, data: ResolutionMode) { @@ -332,24 +332,24 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform override fun transformThisReceiverExpression( thisReceiverExpression: FirThisReceiverExpression, data: ResolutionMode, - ): CompositeTransformResult { + ): FirStatement { return transformQualifiedAccessExpression(thisReceiverExpression, data) } override fun transformComparisonExpression( comparisonExpression: FirComparisonExpression, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { return (comparisonExpression.transformChildren(transformer, ResolutionMode.ContextIndependent) as FirComparisonExpression).also { it.resultType = comparisonExpression.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type) dataFlowAnalyzer.exitComparisonExpressionCall(it) - }.compose() + } } override fun transformAssignmentOperatorStatement( assignmentOperatorStatement: FirAssignmentOperatorStatement, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { require(assignmentOperatorStatement.operation != FirOperation.ASSIGN) assignmentOperatorStatement.transformAnnotations(transformer, ResolutionMode.ContextIndependent) @@ -392,7 +392,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform operatorIsError || (!lhsIsVar && !assignIsError) -> { callCompleter.completeCall(resolvedAssignCall, noExpectedType) dataFlowAnalyzer.exitFunctionCall(resolvedAssignCall, callCompleted = true) - resolvedAssignCall.compose() + resolvedAssignCall } assignIsError -> { callCompleter.completeCall(resolvedOperatorCall, lhsVariable?.returnTypeRef ?: noExpectedType) @@ -430,7 +430,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform buildErrorExpression { source = assignmentOperatorStatement.source diagnostic = ConeOperatorAmbiguityError(listOf(operatorCallSymbol, assignmentCallSymbol)) - }.compose() + } } } } @@ -438,11 +438,11 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform override fun transformEqualityOperatorCall( equalityOperatorCall: FirEqualityOperatorCall, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { val result = (equalityOperatorCall.transformChildren(transformer, ResolutionMode.ContextIndependent) as FirEqualityOperatorCall) .also { it.resultType = equalityOperatorCall.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type) } dataFlowAnalyzer.exitEqualityOperatorCall(result) - return result.compose() + return result } private inline fun resolveCandidateForAssignmentOperatorCall(block: () -> T): T { @@ -540,22 +540,22 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform override fun transformTypeOperatorCall( typeOperatorCall: FirTypeOperatorCall, data: ResolutionMode, - ): CompositeTransformResult { + ): FirStatement { val resolved = components.typeResolverTransformer.withAllowedBareTypes { typeOperatorCall.transformConversionTypeRef(transformer, ResolutionMode.ContextIndependent) }.transformOtherChildren(transformer, ResolutionMode.ContextIndependent) val conversionTypeRef = resolved.conversionTypeRef.withTypeArgumentsForBareType(resolved.argument) resolved.transformChildren(object : FirDefaultTransformer() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult { + override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): FirTypeRef { return if (typeRef === resolved.conversionTypeRef) { - conversionTypeRef.compose() + conversionTypeRef } else { - typeRef.compose() + typeRef } } }, null) @@ -582,19 +582,19 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform else -> error("Unknown type operator: ${resolved.operation}") } dataFlowAnalyzer.exitTypeOperatorCall(resolved) - return resolved.compose() + return resolved } override fun transformCheckNotNullCall( checkNotNullCall: FirCheckNotNullCall, data: ResolutionMode, - ): CompositeTransformResult { + ): FirStatement { // Resolve the return type of a call to the synthetic function with signature: // fun checkNotNull(arg: K?): K // ...in order to get the not-nullable type of the argument. if (checkNotNullCall.calleeReference is FirResolvedNamedReference && checkNotNullCall.resultType !is FirImplicitTypeRef) { - return checkNotNullCall.compose() + return checkNotNullCall } checkNotNullCall.argumentList.transformArguments(transformer, ResolutionMode.ContextDependent) @@ -613,13 +613,13 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform checkNotNullCall } dataFlowAnalyzer.exitCheckNotNullCall(result, callCompleted) - return result.compose() + return result } override fun transformBinaryLogicExpression( binaryLogicExpression: FirBinaryLogicExpression, data: ResolutionMode, - ): CompositeTransformResult { + ): FirStatement { val booleanType = binaryLogicExpression.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type) return when (binaryLogicExpression.kind) { LogicOperationKind.AND -> @@ -635,13 +635,13 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform .transformRightOperand(this, ResolutionMode.WithExpectedType(booleanType)).also(dataFlowAnalyzer::exitBinaryOr) }.transformOtherChildren(transformer, ResolutionMode.WithExpectedType(booleanType)).also { it.resultType = booleanType - }.compose() + } } override fun transformVariableAssignment( variableAssignment: FirVariableAssignment, data: ResolutionMode, - ): CompositeTransformResult { + ): FirStatement { // val resolvedAssignment = transformCallee(variableAssignment) variableAssignment.transformAnnotations(transformer, ResolutionMode.ContextIndependent) val resolvedAssignment = callResolver.resolveVariableAccessAndSelectCandidate(variableAssignment) @@ -654,15 +654,15 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform resolvedAssignment } (result as? FirVariableAssignment)?.let { dataFlowAnalyzer.exitVariableAssignment(it) } - return result.compose() + return result } override fun transformCallableReferenceAccess( callableReferenceAccess: FirCallableReferenceAccess, data: ResolutionMode, - ): CompositeTransformResult { + ): FirStatement { if (callableReferenceAccess.calleeReference is FirResolvedNamedReference) { - return callableReferenceAccess.compose() + return callableReferenceAccess } callableReferenceAccess.transformAnnotations(transformer, data) @@ -686,23 +686,23 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform ) ?: callableReferenceAccess dataFlowAnalyzer.exitCallableReference(resolvedReference) - return resolvedReference.compose() + return resolvedReference } context.storeCallableReferenceContext(callableReferenceAccess) dataFlowAnalyzer.exitCallableReference(callableReferenceAccessWithTransformedLHS) - return callableReferenceAccessWithTransformedLHS.compose() + return callableReferenceAccessWithTransformedLHS } - override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): CompositeTransformResult { + override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): FirStatement { val arg = getClassCall.argument val dataWithExpectedType = if (arg is FirConstExpression<*>) { withExpectedType(arg.typeRef.resolvedTypeFromPrototype(arg.kind.expectedConeType(session))) } else { data } - val transformedGetClassCall = transformExpression(getClassCall, dataWithExpectedType).single as FirGetClassCall + val transformedGetClassCall = transformExpression(getClassCall, dataWithExpectedType) as FirGetClassCall val typeOfExpression = when (val lhs = transformedGetClassCall.argument) { is FirResolvedQualifier -> { @@ -742,13 +742,13 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform buildResolvedTypeRef { type = StandardClassIds.KClass.constructClassLikeType(arrayOf(typeOfExpression), false) } - return transformedGetClassCall.compose() + return transformedGetClassCall } override fun transformConstExpression( constExpression: FirConstExpression, data: ResolutionMode, - ): CompositeTransformResult { + ): FirStatement { constExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent) val type = when (val kind = constExpression.kind) { @@ -770,27 +770,27 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform dataFlowAnalyzer.exitConstExpression(constExpression as FirConstExpression<*>) constExpression.resultType = constExpression.resultType.resolvedTypeFromPrototype(type) - return constExpression.compose() + return constExpression } - override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult { - if (annotationCall.resolveStatus == FirAnnotationResolveStatus.Resolved) return annotationCall.compose() + override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement { + if (annotationCall.resolveStatus == FirAnnotationResolveStatus.Resolved) return annotationCall return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.Resolved) } protected fun resolveAnnotationCall( annotationCall: FirAnnotationCall, status: FirAnnotationResolveStatus - ): CompositeTransformResult { + ): FirAnnotationCall { dataFlowAnalyzer.enterAnnotationCall(annotationCall) return withFirArrayOfCallTransformer { annotationCall.transformAnnotationTypeRef(transformer, ResolutionMode.ContextIndependent) - if (status == FirAnnotationResolveStatus.PartiallyResolved) return annotationCall.compose() - val result = callResolver.resolveAnnotationCall(annotationCall) ?: return annotationCall.compose() + if (status == FirAnnotationResolveStatus.PartiallyResolved) return annotationCall + val result = callResolver.resolveAnnotationCall(annotationCall) ?: return annotationCall callCompleter.completeCall(result, noExpectedType) result.replaceResolveStatus(status) dataFlowAnalyzer.exitAnnotationCall(result) - annotationCall.compose() + annotationCall } } @@ -806,10 +806,10 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform override fun transformDelegatedConstructorCall( delegatedConstructorCall: FirDelegatedConstructorCall, data: ResolutionMode, - ): CompositeTransformResult { - if (transformer.implicitTypeOnly) return delegatedConstructorCall.compose() + ): FirStatement { + if (transformer.implicitTypeOnly) return delegatedConstructorCall when (delegatedConstructorCall.calleeReference) { - is FirResolvedNamedReference, is FirErrorNamedReference -> return delegatedConstructorCall.compose() + is FirResolvedNamedReference, is FirErrorNamedReference -> return delegatedConstructorCall } val containers = components.context.containers val containingClass = containers[containers.lastIndex - 1] as FirClass<*> @@ -839,15 +839,15 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform val reference = delegatedConstructorCall.calleeReference val constructorType: ConeClassLikeType = when (reference) { is FirThisReference -> { - lastDispatchReceiver?.type as? ConeClassLikeType ?: return delegatedConstructorCall.compose() + lastDispatchReceiver?.type as? ConeClassLikeType ?: return delegatedConstructorCall } is FirSuperReference -> { // TODO: unresolved supertype val supertype = reference.superTypeRef.coneTypeSafe() - ?.takeIf { it !is ConeClassErrorType } ?: return delegatedConstructorCall.compose() + ?.takeIf { it !is ConeClassErrorType } ?: return delegatedConstructorCall supertype.fullyExpandedType(session) } - else -> return delegatedConstructorCall.compose() + else -> return delegatedConstructorCall } val resolvedCall = callResolver.resolveDelegatingConstructorCall(delegatedConstructorCall, constructorType) @@ -862,7 +862,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform val completionResult = callCompleter.completeCall(resolvedCall, noExpectedType) result = completionResult.result callCompleted = completionResult.callCompleted - return result.compose() + return result } finally { dataFlowAnalyzer.exitDelegatedConstructorCall(result, callCompleted) } @@ -881,7 +881,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform override fun transformAugmentedArraySetCall( augmentedArraySetCall: FirAugmentedArraySetCall, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { assert(augmentedArraySetCall.operation in FirOperation.ASSIGNMENTS) assert(augmentedArraySetCall.operation != FirOperation.ASSIGN) @@ -936,7 +936,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform } } } - return result.compose() + return result } // ------------------------------------------------------------------------------------------------ diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt index 48c925bce58..2664c611f99 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt @@ -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.FirResolvedTypeRef 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.compose import org.jetbrains.kotlin.utils.addToStdlib.runIf @OptIn(AdapterForResolveProcessor::class) @@ -47,11 +45,11 @@ class FirImplicitTypeBodyResolveTransformerAdapter(session: FirSession, scopeSes returnTypeCalculator ) - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { + override fun transformFile(file: FirFile, data: Nothing?): FirFile { return file.transform(transformer, ResolutionMode.ContextIndependent) } } @@ -94,7 +92,7 @@ fun > F.runContractAndBodiesResolutionForLocalCla val members = localClassesNavigationInfo.allMembers graphBuilder.prepareForLocalClassMembers(members) - return this.transform(transformer, resolutionMode).single.also { + return this.transform(transformer, resolutionMode).also { graphBuilder.cleanAfterForLocalClassMembers(members) } } @@ -138,13 +136,13 @@ open class FirImplicitAwareBodyResolveTransformer( override fun transformSimpleFunction( simpleFunction: FirSimpleFunction, data: ResolutionMode - ): CompositeTransformResult { + ): FirSimpleFunction { return computeCachedTransformationResult(simpleFunction) { super.transformSimpleFunction(simpleFunction, data) } } - override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty { return computeCachedTransformationResult(property) { super.transformProperty(property, data) } @@ -152,18 +150,18 @@ open class FirImplicitAwareBodyResolveTransformer( private fun > computeCachedTransformationResult( member: D, - transform: () -> CompositeTransformResult - ): CompositeTransformResult { + transform: () -> D + ): D { if (!implicitTypeOnly && member.returnTypeRef is FirResolvedTypeRef) { return transform() } - if (member.returnTypeRef is FirResolvedTypeRef) return member.compose() + if (member.returnTypeRef is FirResolvedTypeRef) return member val symbol = member.symbol val status = implicitBodyResolveComputationSession.getStatus(symbol) if (status is ImplicitBodyResolveComputationStatus.Computed) { @Suppress("UNCHECKED_CAST") - return status.transformedDeclaration.compose() as CompositeTransformResult + return status.transformedDeclaration as D } // 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) val result = transform() - implicitBodyResolveComputationSession.storeResult(symbol, result.single) + implicitBodyResolveComputationSession.storeResult(symbol, result) return result } @@ -303,13 +301,13 @@ open class FirDesignatedBodyResolveTransformerForReturnTypeCalculator( ) { var lastResult: FirElement? = null - override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult { + override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration { if (designation.hasNext()) { - val result = designation.next().transform(this, data).single + val result = designation.next().transform(this, data) if (!designation.hasNext() && lastResult == null) { lastResult = result } - return declaration.compose() + return declaration } return super.transformDeclarationContent(declaration, data) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt index b37b2ececc0..62e05cb5ef9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt @@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.PrivateForInline import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext -import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult abstract class FirPartialBodyResolveTransformer( val transformer: FirBodyResolveTransformer @@ -33,7 +32,7 @@ abstract class FirPartialBodyResolveTransformer( transformer.implicitTypeOnly = value } - override fun transformElement(element: E, data: ResolutionMode): CompositeTransformResult { + override fun transformElement(element: E, data: ResolutionMode): E { return element.transform(transformer, data) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt index 36733eb8073..98b82e0a390 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt @@ -43,18 +43,18 @@ open class FirContractResolveTransformer( ) { override val declarationsTransformer: FirDeclarationsResolveTransformer = FirDeclarationsContractResolveTransformer(this) - override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult { - return annotationCall.compose() + override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement { + return annotationCall } private class FirDeclarationsContractResolveTransformer(transformer: FirBodyResolveTransformer) : FirDeclarationsResolveTransformer(transformer) { override fun transformSimpleFunction( simpleFunction: FirSimpleFunction, data: ResolutionMode - ): CompositeTransformResult { + ): FirSimpleFunction { simpleFunction.updatePhase() if (!simpleFunction.hasContractToResolve) { - return simpleFunction.compose() + return simpleFunction } val containingDeclaration = context.containerIfAny if (containingDeclaration != null && containingDeclaration !is FirClass<*>) { @@ -63,7 +63,7 @@ open class FirContractResolveTransformer( ConeContractDescriptionError("Local function can not be used in contract description") ) ) - return simpleFunction.compose() + return simpleFunction } @Suppress("UNCHECKED_CAST") return context.withSimpleFunction(simpleFunction) { @@ -73,37 +73,37 @@ open class FirContractResolveTransformer( } } - override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty { property.updatePhase() if ( property.getter?.hasContractToResolve != true && property.setter?.hasContractToResolve != true || property.isLocal || property.delegate != null ) { - return property.compose() + return property } if (property is FirSyntheticProperty) { transformSimpleFunction(property.getter.delegate, data) - return property.compose() + return property } context.withProperty(property) { property.getter?.let { transformPropertyAccessor(it, property) } property.setter?.let { transformPropertyAccessor(it, property) } } - return property.compose() + return property } - override fun transformField(field: FirField, data: ResolutionMode): CompositeTransformResult { + override fun transformField(field: FirField, data: ResolutionMode): FirDeclaration { field.updatePhase() - return field.compose() + return field } private fun transformPropertyAccessor( propertyAccessor: FirPropertyAccessor, owner: FirProperty - ): CompositeTransformResult { + ): FirStatement { propertyAccessor.updatePhase() if (!propertyAccessor.hasContractToResolve) { - return propertyAccessor.compose() + return propertyAccessor } return context.withPropertyAccessor(owner, propertyAccessor, components, forContracts = true) { transformContractDescriptionOwner(propertyAccessor) @@ -112,7 +112,7 @@ open class FirContractResolveTransformer( private fun transformContractDescriptionOwner( owner: T - ): CompositeTransformResult { + ): T { dataFlowAnalyzer.enterContractDescription() return when (val contractDescription = owner.contractDescription) { is FirLegacyRawContractDescription -> transformLegacyRawContractDescriptionOwner(owner, contractDescription) @@ -124,7 +124,7 @@ open class FirContractResolveTransformer( private fun transformLegacyRawContractDescriptionOwner( owner: T, contractDescription: FirLegacyRawContractDescription - ): CompositeTransformResult { + ): T { val valueParameters = owner.valueParameters for (valueParameter in valueParameters) { context.storeVariable(valueParameter) @@ -150,13 +150,13 @@ open class FirContractResolveTransformer( } owner.replaceContractDescription(resolvedContractDescription) dataFlowAnalyzer.exitContractDescription() - return owner.compose() + return owner } private fun transformRawContractDescriptionOwner( owner: T, contractDescription: FirRawContractDescription - ): CompositeTransformResult { + ): T { val effectsBlock = buildAnonymousFunction { session = this@FirDeclarationsContractResolveTransformer.session origin = FirDeclarationOrigin.Source @@ -194,64 +194,64 @@ open class FirContractResolveTransformer( return transformLegacyRawContractDescriptionOwner(owner, legacyRawContractDescription) } - private fun transformOwnerWithUnresolvedContract(owner: T): CompositeTransformResult { + private fun transformOwnerWithUnresolvedContract(owner: T): T { return when (val contractDescription = owner.contractDescription) { is FirLegacyRawContractDescription -> { // old syntax contract description val functionCall = contractDescription.contractCall owner.replaceContractDescription(FirEmptyContractDescription) owner.body.replaceFirstStatement(functionCall) dataFlowAnalyzer.exitContractDescription() - owner.compose() + owner } is FirRawContractDescription -> { // new syntax contract description owner.replaceContractDescription(FirEmptyContractDescription) dataFlowAnalyzer.exitContractDescription() - owner.compose() + owner } - else -> owner.compose() // TODO: change + else -> owner // TODO: change } } - override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult { + override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement { regularClass.updatePhase() regularClass.transformCompanionObject(this, data) context.withRegularClass(regularClass, components, forContracts = true) { regularClass.transformDeclarations(this, data) } - return regularClass.compose() + return regularClass } override fun transformAnonymousObject( anonymousObject: FirAnonymousObject, data: ResolutionMode - ): CompositeTransformResult { + ): FirStatement { anonymousObject.updatePhase() context.withAnonymousObject(anonymousObject, components) { anonymousObject.transformDeclarations(this, data) } - return anonymousObject.compose() + return anonymousObject } override fun transformAnonymousInitializer( anonymousInitializer: FirAnonymousInitializer, data: ResolutionMode - ): CompositeTransformResult { - return anonymousInitializer.compose() + ): FirDeclaration { + return anonymousInitializer } - override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult { + override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration { constructor.updatePhase() - return constructor.compose() + return constructor } - override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): CompositeTransformResult { - return enumEntry.compose() + override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirDeclaration { + return enumEntry } - private fun transformOwnerOfErrorContract(owner: T): CompositeTransformResult { + private fun transformOwnerOfErrorContract(owner: T): T { // TODO dataFlowAnalyzer.exitContractDescription() - return owner.compose() + return owner } private val FirContractDescriptionOwner.hasContractToResolve: Boolean diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt index a44a8e61bd1..e897825e493 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers.contracts import org.jetbrains.kotlin.fir.FirElement 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.FirDeclaration 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.ReturnTypeCalculatorForFullBodyResolve 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.compose import org.jetbrains.kotlin.fir.visitors.transformSingle @OptIn(AdapterForResolveProcessor::class) @@ -31,11 +27,11 @@ class FirContractResolveProcessor(session: FirSession, scopeSession: ScopeSessio @AdapterForResolveProcessor class FirContractResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer() { private val transformer = FirContractResolveTransformer(session, scopeSession) - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { + override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration { return file.transform(transformer, ResolutionMode.ContextIndependent) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt index 01eaea100f4..83561d224a2 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt @@ -16,19 +16,17 @@ import org.jetbrains.kotlin.fir.scopes.FirCompositeScope import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.createImportingScopes 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.compose internal abstract class FirAbstractAnnotationResolveTransformer( protected val session: FirSession, protected val scopeSession: ScopeSession ) : FirDefaultTransformer() { - abstract override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult + abstract override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement protected lateinit var scope: FirScope - override fun transformFile(file: FirFile, data: D): CompositeTransformResult { + override fun transformFile(file: FirFile, data: D): FirDeclaration { scope = FirCompositeScope(createImportingScopes(file, session, scopeSession, useCaching = false)) val state = beforeChildren(file) file.transformDeclarations(this, data) @@ -36,14 +34,14 @@ internal abstract class FirAbstractAnnotationResolveTransformer( return transformAnnotatedDeclaration(file, data) } - override fun transformProperty(property: FirProperty, data: D): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: D): FirDeclaration { return transformAnnotatedDeclaration(property, data) } override fun transformRegularClass( regularClass: FirRegularClass, data: D - ): CompositeTransformResult { + ): FirStatement { @Suppress("UNCHECKED_CAST") return transformAnnotatedDeclaration(regularClass, data).also { val state = beforeChildren(regularClass) @@ -51,13 +49,13 @@ internal abstract class FirAbstractAnnotationResolveTransformer( regularClass.transformCompanionObject(this, data) regularClass.transformSuperTypeRefs(this, data) afterChildren(state) - } as CompositeTransformResult + } as FirStatement } override fun transformSimpleFunction( simpleFunction: FirSimpleFunction, data: D - ): CompositeTransformResult { + ): FirDeclaration { return transformAnnotatedDeclaration(simpleFunction, data).also { val state = beforeChildren(simpleFunction) simpleFunction.transformValueParameters(this, data) @@ -68,7 +66,7 @@ internal abstract class FirAbstractAnnotationResolveTransformer( override fun transformConstructor( constructor: FirConstructor, data: D - ): CompositeTransformResult { + ): FirDeclaration { return transformAnnotatedDeclaration(constructor, data).also { val state = beforeChildren(constructor) constructor.transformValueParameters(this, data) @@ -79,37 +77,37 @@ internal abstract class FirAbstractAnnotationResolveTransformer( override fun transformValueParameter( valueParameter: FirValueParameter, data: D - ): CompositeTransformResult { + ): FirStatement { @Suppress("UNCHECKED_CAST") - return transformAnnotatedDeclaration(valueParameter, data) as CompositeTransformResult + return transformAnnotatedDeclaration(valueParameter, data) as FirStatement } - override fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult { + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): FirDeclaration { return transformAnnotatedDeclaration(typeAlias, data) } - override fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult { + override fun transformTypeRef(typeRef: FirTypeRef, data: D): FirTypeRef { @Suppress("UNCHECKED_CAST") - return transformAnnotationContainer(typeRef, data) as CompositeTransformResult + return transformAnnotationContainer(typeRef, data) as FirTypeRef } override fun transformAnnotatedDeclaration( annotatedDeclaration: FirAnnotatedDeclaration, data: D - ): CompositeTransformResult { + ): FirDeclaration { @Suppress("UNCHECKED_CAST") - return transformAnnotationContainer(annotatedDeclaration, data) as CompositeTransformResult + return transformAnnotationContainer(annotatedDeclaration, data) as FirDeclaration } override fun transformAnnotationContainer( annotationContainer: FirAnnotationContainer, data: D - ): CompositeTransformResult { - return annotationContainer.transformAnnotations(this, data).compose() + ): FirAnnotationContainer { + return annotationContainer.transformAnnotations(this, data) } - override fun transformElement(element: E, data: D): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: D): E { + return element } protected open fun beforeChildren(declaration: FirAnnotatedDeclaration): S? { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt index d82428278fd..2a93bcd64d0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveProcessor.kt @@ -15,9 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor 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.compose @OptIn(AdapterForResolveProcessor::class) class FirAnnotationArgumentsResolveProcessor( @@ -33,12 +31,12 @@ class FirAnnotationArgumentsResolveTransformerAdapter(session: FirSession, scope private val hasAnnotations = session.registeredPluginAnnotations.annotations.isNotEmpty() private val predicateBasedProvider = session.predicateBasedProvider - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { - if (!hasAnnotations || !predicateBasedProvider.fileHasPluginAnnotations(file)) return file.compose() + override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration { + if (!hasAnnotations || !predicateBasedProvider.fileHasPluginAnnotations(file)) return file return file.transform(transformer, ResolutionMode.ContextIndependent) } } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt index d4a6587e8e2..ef4537053e0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt @@ -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.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.coneTypeSafe -import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult -import org.jetbrains.kotlin.fir.visitors.compose class FirAnnotationArgumentsResolveTransformer( session: FirSession, @@ -47,49 +45,49 @@ private class FirDeclarationsResolveTransformerForArgumentAnnotations( override fun transformWrappedDelegateExpression( wrappedDelegateExpression: FirWrappedDelegateExpression, data: ResolutionMode - ): CompositeTransformResult { - return wrappedDelegateExpression.compose() + ): FirStatement { + return wrappedDelegateExpression } - override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult { - return regularClass.transformAnnotations(this, data).transformDeclarations(this, data).compose() + override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement { + return regularClass.transformAnnotations(this, data).transformDeclarations(this, data) } override fun transformAnonymousInitializer( anonymousInitializer: FirAnonymousInitializer, data: ResolutionMode - ): CompositeTransformResult { - return anonymousInitializer.compose() + ): FirDeclaration { + return anonymousInitializer } override fun transformSimpleFunction( simpleFunction: FirSimpleFunction, data: ResolutionMode - ): CompositeTransformResult { - return simpleFunction.transformAnnotations(this, data).compose() + ): FirSimpleFunction { + return simpleFunction.transformAnnotations(this, data) } - override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult { - return constructor.transformAnnotations(this, data).compose() + override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration { + return constructor.transformAnnotations(this, data) } - override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult { - return valueParameter.transformAnnotations(this, data).compose() + override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement { + return valueParameter.transformAnnotations(this, data) } - override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty { property.transformAnnotations(this, data) property.transformGetter(this, data) property.transformSetter(this, data) - return property.compose() + return property } override fun transformPropertyAccessor( propertyAccessor: FirPropertyAccessor, data: ResolutionMode - ): CompositeTransformResult { + ): FirDeclaration { propertyAccessor.transformAnnotations(this, data) - return propertyAccessor.compose() + return propertyAccessor } } @@ -99,16 +97,16 @@ private class FirExpressionsResolveTransformerForSpecificAnnotations( ) : FirExpressionsResolveTransformer(transformer) { private var annotationArgumentsMode: Boolean = false - override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult { + override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement { if (annotationArgumentsMode) { return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.PartiallyResolved) } annotationCall.transformAnnotationTypeRef(transformer, data) val classId = annotationCall.annotationTypeRef.coneTypeSafe()?.lookupTag?.classId - ?: return annotationCall.compose() + ?: return annotationCall if (classId.asSingleFqName() !in annotations) { - return annotationCall.compose() + return annotationCall } annotationArgumentsMode = true return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.PartiallyResolved).also { @@ -116,82 +114,82 @@ private class FirExpressionsResolveTransformerForSpecificAnnotations( } } - override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult { - return expression.compose() + override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement { + return expression } override fun FirQualifiedAccessExpression.isAcceptableResolvedQualifiedAccess(): Boolean { return calleeReference !is FirErrorNamedReference } - override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult { - return functionCall.compose() + override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): FirStatement { + return functionCall } - override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult { - return block.compose() + override fun transformBlock(block: FirBlock, data: ResolutionMode): FirStatement { + return block } override fun transformThisReceiverExpression( thisReceiverExpression: FirThisReceiverExpression, data: ResolutionMode - ): CompositeTransformResult { - return thisReceiverExpression.compose() + ): FirStatement { + return thisReceiverExpression } override fun transformComparisonExpression( comparisonExpression: FirComparisonExpression, data: ResolutionMode - ): CompositeTransformResult { - return comparisonExpression.compose() + ): FirStatement { + return comparisonExpression } override fun transformTypeOperatorCall( typeOperatorCall: FirTypeOperatorCall, data: ResolutionMode - ): CompositeTransformResult { - return typeOperatorCall.compose() + ): FirStatement { + return typeOperatorCall } override fun transformCheckNotNullCall( checkNotNullCall: FirCheckNotNullCall, data: ResolutionMode - ): CompositeTransformResult { - return checkNotNullCall.compose() + ): FirStatement { + return checkNotNullCall } override fun transformBinaryLogicExpression( binaryLogicExpression: FirBinaryLogicExpression, data: ResolutionMode - ): CompositeTransformResult { - return binaryLogicExpression.compose() + ): FirStatement { + return binaryLogicExpression } override fun transformVariableAssignment( variableAssignment: FirVariableAssignment, data: ResolutionMode - ): CompositeTransformResult { - return variableAssignment.compose() + ): FirStatement { + return variableAssignment } override fun transformCallableReferenceAccess( callableReferenceAccess: FirCallableReferenceAccess, data: ResolutionMode - ): CompositeTransformResult { - return callableReferenceAccess.compose() + ): FirStatement { + return callableReferenceAccess } override fun transformDelegatedConstructorCall( delegatedConstructorCall: FirDelegatedConstructorCall, data: ResolutionMode - ): CompositeTransformResult { - return delegatedConstructorCall.compose() + ): FirStatement { + return delegatedConstructorCall } override fun transformAugmentedArraySetCall( augmentedArraySetCall: FirAugmentedArraySetCall, data: ResolutionMode - ): CompositeTransformResult { - return augmentedArraySetCall.compose() + ): FirStatement { + return augmentedArraySetCall } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalExtensionStatusProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalExtensionStatusProcessor.kt index 9305d649427..c0abbe894db 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalExtensionStatusProcessor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalExtensionStatusProcessor.kt @@ -15,10 +15,8 @@ import org.jetbrains.kotlin.fir.extensions.statusTransformerExtensions import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.FirGlobalResolveProcessor 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.FirTransformer -import org.jetbrains.kotlin.fir.visitors.compose class FirGlobalExtensionStatusProcessor( session: FirSession, @@ -62,59 +60,59 @@ class FirTransformerBasedExtensionStatusProcessor( transformStatus(ReplaceStatus, status) } - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: Nothing?): E { + return element } - override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult { + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): FirDeclaration { typeAlias.updateStatus() - return typeAlias.compose() + return typeAlias } - override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult { + override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement { regularClass.updateStatus() regularClass.transformDeclarations(this, data) - return regularClass.compose() + return regularClass } - override fun transformConstructor(constructor: FirConstructor, data: Nothing?): CompositeTransformResult { + override fun transformConstructor(constructor: FirConstructor, data: Nothing?): FirDeclaration { constructor.updateStatus() - return constructor.compose() + return constructor } - override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: Nothing?): FirDeclaration { property.updateStatus() property.transformGetter(this, data) property.transformSetter(this, data) - return property.compose() + return property } - override fun transformField(field: FirField, data: Nothing?): CompositeTransformResult { + override fun transformField(field: FirField, data: Nothing?): FirDeclaration { field.updateStatus() - return field.compose() + return field } - override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): CompositeTransformResult { + override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): FirDeclaration { enumEntry.updateStatus() - return enumEntry.compose() + return enumEntry } - override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): CompositeTransformResult { + override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): FirDeclaration { simpleFunction.updateStatus() - return simpleFunction.compose() + return simpleFunction } } } private object ReplaceStatus : FirTransformer() { - override fun transformElement(element: E, data: FirDeclarationStatus): CompositeTransformResult { - return element.compose() + override fun transformElement(element: E, data: FirDeclarationStatus): E { + return element } override fun transformDeclarationStatus( declarationStatus: FirDeclarationStatus, data: FirDeclarationStatus - ): CompositeTransformResult { - return data.compose() + ): FirDeclarationStatus { + return data } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt index 8b7e1f9192c..8ce6f6abf13 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt @@ -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.FirSpecificTypeResolverTransformer 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 class FirPluginAnnotationsResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) { @@ -38,13 +36,13 @@ class FirPluginAnnotationsResolveTransformer( private val importTransformer = FirPartialImportResolveTransformer(session) val extensionService = session.extensionService - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { + override fun transformElement(element: E, data: Nothing?): E { throw IllegalStateException("Should not be here") } - override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { + override fun transformFile(file: FirFile, data: Nothing?): FirFile { checkSessionConsistency(file) - if (!extensionService.hasPredicateBasedExtensions) return file.compose() + if (!extensionService.hasPredicateBasedExtensions) return file val registeredPluginAnnotations = file.session.registeredPluginAnnotations file.replaceResolvePhase(FirResolvePhase.ANNOTATIONS_FOR_PLUGINS) val newAnnotations = file.resolveAnnotations(registeredPluginAnnotations.annotations, registeredPluginAnnotations.metaAnnotations) @@ -55,7 +53,7 @@ class FirPluginAnnotationsResolveTransformer( val newAnnotationsFqns = newAnnotations.values().mapTo(mutableSetOf()) { it.symbol.classId.asSingleFqName() } file.resolveAnnotations(newAnnotationsFqns, emptySet()) } - return file.compose() + return file } private fun FirFile.resolveAnnotations( @@ -107,14 +105,14 @@ private class FirAnnotationResolveTransformer( override fun transformAnnotationCall( annotationCall: FirAnnotationCall, data: Multimap - ): CompositeTransformResult { - return annotationCall.transformAnnotationTypeRef(typeResolverTransformer, scope).compose() + ): FirStatement { + return annotationCall.transformAnnotationTypeRef(typeResolverTransformer, scope) } override fun transformRegularClass( regularClass: FirRegularClass, data: Multimap - ): CompositeTransformResult { + ): FirStatement { return super.transformRegularClass(regularClass, data).also { if (regularClass.classKind == ClassKind.ANNOTATION_CLASS && metaAnnotations.isNotEmpty()) { val annotations = regularClass.annotations.mapNotNull { it.fqName(session) } @@ -128,7 +126,7 @@ private class FirAnnotationResolveTransformer( override fun transformAnnotatedDeclaration( annotatedDeclaration: FirAnnotatedDeclaration, data: Multimap - ): CompositeTransformResult { + ): FirDeclaration { return super.transformAnnotatedDeclaration(annotatedDeclaration, data).also { session.predicateBasedProvider.registerAnnotatedDeclaration(annotatedDeclaration, owners) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultSimpleImportingScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultSimpleImportingScope.kt index 19673ffcb58..c00dfa543d0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultSimpleImportingScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDefaultSimpleImportingScope.kt @@ -20,7 +20,7 @@ class FirDefaultSimpleImportingScope( ) : FirAbstractSimpleImportingScope(session, scopeSession) { private fun FirImport.resolve(importResolveTransformer: FirImportResolveTransformer) = - importResolveTransformer.transformImport(this, null).single as FirResolvedImport + importResolveTransformer.transformImport(this, null) as FirResolvedImport override val simpleImports = run { val importResolveTransformer = FirImportResolveTransformer(session) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/FirElement.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/FirElement.kt index e1bf6d31110..a91c78e6aba 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/FirElement.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/FirElement.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir -import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult import org.jetbrains.kotlin.fir.visitors.* /* @@ -25,8 +24,8 @@ interface FirElement { fun acceptChildren(visitor: FirVisitorVoid) = acceptChildren(visitor, null) @Suppress("UNCHECKED_CAST") - fun transform(visitor: FirTransformer, data: D): CompositeTransformResult = - accept(visitor, data) as CompositeTransformResult + fun transform(visitor: FirTransformer, data: D): E = + accept(visitor, data) as E fun transformChildren(transformer: FirTransformer, data: D): FirElement } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt index 58120544f03..dd9216418e5 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt @@ -130,1010 +130,1009 @@ import org.jetbrains.kotlin.fir.contracts.FirContractDescription import org.jetbrains.kotlin.fir.contracts.FirLegacyRawContractDescription import org.jetbrains.kotlin.fir.contracts.FirRawContractDescription import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription -import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult /* * This file was generated automatically * DO NOT MODIFY IT MANUALLY */ -abstract class FirTransformer : FirVisitor, D>() { +abstract class FirTransformer : FirVisitor() { - abstract fun transformElement(element: E, data: D): CompositeTransformResult + abstract fun transformElement(element: E, data: D): E - open fun transformAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): CompositeTransformResult { + open fun transformAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): FirAnnotationContainer { return transformElement(annotationContainer, data) } - open fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult { + open fun transformTypeRef(typeRef: FirTypeRef, data: D): FirTypeRef { return transformElement(typeRef, data) } - open fun transformReference(reference: FirReference, data: D): CompositeTransformResult { + open fun transformReference(reference: FirReference, data: D): FirReference { return transformElement(reference, data) } - open fun transformLabel(label: FirLabel, data: D): CompositeTransformResult { + open fun transformLabel(label: FirLabel, data: D): FirLabel { return transformElement(label, data) } - open fun transformImport(import: FirImport, data: D): CompositeTransformResult { + open fun transformImport(import: FirImport, data: D): FirImport { return transformElement(import, data) } - open fun transformResolvedImport(resolvedImport: FirResolvedImport, data: D): CompositeTransformResult { + open fun transformResolvedImport(resolvedImport: FirResolvedImport, data: D): FirImport { return transformElement(resolvedImport, data) } - open fun transformSymbolOwner(symbolOwner: FirSymbolOwner, data: D): CompositeTransformResult> where E : FirSymbolOwner, E : FirDeclaration { + open fun transformSymbolOwner(symbolOwner: FirSymbolOwner, data: D): FirSymbolOwner where E : FirSymbolOwner, E : FirDeclaration { return transformElement(symbolOwner, data) } - open fun transformResolvable(resolvable: FirResolvable, data: D): CompositeTransformResult { + open fun transformResolvable(resolvable: FirResolvable, data: D): FirResolvable { return transformElement(resolvable, data) } - open fun transformTargetElement(targetElement: FirTargetElement, data: D): CompositeTransformResult { + open fun transformTargetElement(targetElement: FirTargetElement, data: D): FirTargetElement { return transformElement(targetElement, data) } - open fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): CompositeTransformResult { + open fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): FirDeclarationStatus { return transformElement(declarationStatus, data) } - open fun transformResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): CompositeTransformResult { + open fun transformResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): FirDeclarationStatus { return transformElement(resolvedDeclarationStatus, data) } - open fun transformControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: D): CompositeTransformResult { + open fun transformControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: D): FirControlFlowGraphOwner { return transformElement(controlFlowGraphOwner, data) } - open fun transformStatement(statement: FirStatement, data: D): CompositeTransformResult { + open fun transformStatement(statement: FirStatement, data: D): FirStatement { return transformElement(statement, data) } - open fun transformExpression(expression: FirExpression, data: D): CompositeTransformResult { + open fun transformExpression(expression: FirExpression, data: D): FirStatement { return transformElement(expression, data) } - open fun transformDeclaration(declaration: FirDeclaration, data: D): CompositeTransformResult { + open fun transformDeclaration(declaration: FirDeclaration, data: D): FirDeclaration { return transformElement(declaration, data) } - open fun transformAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): CompositeTransformResult { + open fun transformAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): FirDeclaration { return transformElement(annotatedDeclaration, data) } - open fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): CompositeTransformResult { + open fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): FirDeclaration { return transformElement(anonymousInitializer, data) } - open fun transformTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): CompositeTransformResult { + open fun transformTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): FirDeclaration { return transformElement(typedDeclaration, data) } - open fun > transformCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): CompositeTransformResult { + open fun > transformCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): FirDeclaration { return transformElement(callableDeclaration, data) } - open fun transformTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: D): CompositeTransformResult { + open fun transformTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: D): FirTypeParameterRef { return transformElement(typeParameterRef, data) } - open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult { + open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): FirDeclaration { return transformElement(typeParameter, data) } - open fun transformTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: D): CompositeTransformResult { + open fun transformTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: D): FirTypeParameterRefsOwner { return transformElement(typeParameterRefsOwner, data) } - open fun transformTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): CompositeTransformResult { + open fun transformTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): FirTypeParametersOwner { return transformElement(typeParametersOwner, data) } - open fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): CompositeTransformResult { + open fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): FirDeclaration { return transformElement(memberDeclaration, data) } - open fun > transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): CompositeTransformResult { + open fun > transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): FirDeclaration { return transformElement(callableMemberDeclaration, data) } - open fun > transformVariable(variable: FirVariable, data: D): CompositeTransformResult { + open fun > transformVariable(variable: FirVariable, data: D): FirStatement { return transformElement(variable, data) } - open fun transformValueParameter(valueParameter: FirValueParameter, data: D): CompositeTransformResult { + open fun transformValueParameter(valueParameter: FirValueParameter, data: D): FirStatement { return transformElement(valueParameter, data) } - open fun transformProperty(property: FirProperty, data: D): CompositeTransformResult { + open fun transformProperty(property: FirProperty, data: D): FirDeclaration { return transformElement(property, data) } - open fun transformField(field: FirField, data: D): CompositeTransformResult { + open fun transformField(field: FirField, data: D): FirDeclaration { return transformElement(field, data) } - open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult { + open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): FirDeclaration { return transformElement(enumEntry, data) } - open fun > transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult { + open fun > transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): FirStatement { return transformElement(classLikeDeclaration, data) } - open fun > transformClass(klass: FirClass, data: D): CompositeTransformResult { + open fun > transformClass(klass: FirClass, data: D): FirStatement { return transformElement(klass, data) } - open fun transformRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult { + open fun transformRegularClass(regularClass: FirRegularClass, data: D): FirStatement { return transformElement(regularClass, data) } - open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult { + open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): FirDeclaration { return transformElement(typeAlias, data) } - open fun > transformFunction(function: FirFunction, data: D): CompositeTransformResult { + open fun > transformFunction(function: FirFunction, data: D): FirStatement { return transformElement(function, data) } - open fun transformContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): CompositeTransformResult { + open fun transformContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): FirContractDescriptionOwner { return transformElement(contractDescriptionOwner, data) } - open fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: D): CompositeTransformResult { + open fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: D): FirDeclaration { return transformElement(simpleFunction, data) } - open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult { + open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): FirDeclaration { return transformElement(propertyAccessor, data) } - open fun transformConstructor(constructor: FirConstructor, data: D): CompositeTransformResult { + open fun transformConstructor(constructor: FirConstructor, data: D): FirDeclaration { return transformElement(constructor, data) } - open fun transformFile(file: FirFile, data: D): CompositeTransformResult { + open fun transformFile(file: FirFile, data: D): FirDeclaration { return transformElement(file, data) } - open fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): CompositeTransformResult { + open fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): FirStatement { return transformElement(anonymousFunction, data) } - open fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: D): CompositeTransformResult { + open fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: D): FirStatement { return transformElement(anonymousObject, data) } - open fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): CompositeTransformResult { + open fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): FirDiagnosticHolder { return transformElement(diagnosticHolder, data) } - open fun transformLoop(loop: FirLoop, data: D): CompositeTransformResult { + open fun transformLoop(loop: FirLoop, data: D): FirStatement { return transformElement(loop, data) } - open fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): CompositeTransformResult { + open fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): FirStatement { return transformElement(errorLoop, data) } - open fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): CompositeTransformResult { + open fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): FirStatement { return transformElement(doWhileLoop, data) } - open fun transformWhileLoop(whileLoop: FirWhileLoop, data: D): CompositeTransformResult { + open fun transformWhileLoop(whileLoop: FirWhileLoop, data: D): FirStatement { return transformElement(whileLoop, data) } - open fun transformBlock(block: FirBlock, data: D): CompositeTransformResult { + open fun transformBlock(block: FirBlock, data: D): FirStatement { return transformElement(block, data) } - open fun transformBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): CompositeTransformResult { + open fun transformBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): FirStatement { return transformElement(binaryLogicExpression, data) } - open fun transformJump(jump: FirJump, data: D): CompositeTransformResult { + open fun transformJump(jump: FirJump, data: D): FirStatement { return transformElement(jump, data) } - open fun transformLoopJump(loopJump: FirLoopJump, data: D): CompositeTransformResult { + open fun transformLoopJump(loopJump: FirLoopJump, data: D): FirStatement { return transformElement(loopJump, data) } - open fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult { + open fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): FirStatement { return transformElement(breakExpression, data) } - open fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult { + open fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): FirStatement { return transformElement(continueExpression, data) } - open fun transformCatch(catch: FirCatch, data: D): CompositeTransformResult { + open fun transformCatch(catch: FirCatch, data: D): FirCatch { return transformElement(catch, data) } - open fun transformTryExpression(tryExpression: FirTryExpression, data: D): CompositeTransformResult { + open fun transformTryExpression(tryExpression: FirTryExpression, data: D): FirStatement { return transformElement(tryExpression, data) } - open fun transformConstExpression(constExpression: FirConstExpression, data: D): CompositeTransformResult { + open fun transformConstExpression(constExpression: FirConstExpression, data: D): FirStatement { return transformElement(constExpression, data) } - open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult { + open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): FirTypeProjection { return transformElement(typeProjection, data) } - open fun transformStarProjection(starProjection: FirStarProjection, data: D): CompositeTransformResult { + open fun transformStarProjection(starProjection: FirStarProjection, data: D): FirTypeProjection { return transformElement(starProjection, data) } - open fun transformTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): CompositeTransformResult { + open fun transformTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): FirTypeProjection { return transformElement(typeProjectionWithVariance, data) } - open fun transformArgumentList(argumentList: FirArgumentList, data: D): CompositeTransformResult { + open fun transformArgumentList(argumentList: FirArgumentList, data: D): FirArgumentList { return transformElement(argumentList, data) } - open fun transformCall(call: FirCall, data: D): CompositeTransformResult { + open fun transformCall(call: FirCall, data: D): FirStatement { return transformElement(call, data) } - open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult { + open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement { return transformElement(annotationCall, data) } - open fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): CompositeTransformResult { + open fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): FirStatement { return transformElement(comparisonExpression, data) } - open fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): CompositeTransformResult { + open fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): FirStatement { return transformElement(typeOperatorCall, data) } - open fun transformAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: D): CompositeTransformResult { + open fun transformAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: D): FirStatement { return transformElement(assignmentOperatorStatement, data) } - open fun transformEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: D): CompositeTransformResult { + open fun transformEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: D): FirStatement { return transformElement(equalityOperatorCall, data) } - open fun transformWhenExpression(whenExpression: FirWhenExpression, data: D): CompositeTransformResult { + open fun transformWhenExpression(whenExpression: FirWhenExpression, data: D): FirStatement { return transformElement(whenExpression, data) } - open fun transformWhenBranch(whenBranch: FirWhenBranch, data: D): CompositeTransformResult { + open fun transformWhenBranch(whenBranch: FirWhenBranch, data: D): FirWhenBranch { return transformElement(whenBranch, data) } - open fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): CompositeTransformResult { + open fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): FirStatement { return transformElement(qualifiedAccess, data) } - open fun transformCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): CompositeTransformResult { + open fun transformCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): FirStatement { return transformElement(checkNotNullCall, data) } - open fun transformElvisExpression(elvisExpression: FirElvisExpression, data: D): CompositeTransformResult { + open fun transformElvisExpression(elvisExpression: FirElvisExpression, data: D): FirStatement { return transformElement(elvisExpression, data) } - open fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult { + open fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): FirStatement { return transformElement(arrayOfCall, data) } - open fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): CompositeTransformResult { + open fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): FirStatement { return transformElement(augmentedArraySetCall, data) } - open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult { + open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): FirStatement { return transformElement(classReferenceExpression, data) } - open fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult { + open fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): FirStatement { return transformElement(errorExpression, data) } - open fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): CompositeTransformResult { + open fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): FirStatement { return transformElement(errorFunction, data) } - open fun transformErrorProperty(errorProperty: FirErrorProperty, data: D): CompositeTransformResult { + open fun transformErrorProperty(errorProperty: FirErrorProperty, data: D): FirStatement { return transformElement(errorProperty, data) } - open fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): CompositeTransformResult { + open fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): FirStatement { return transformElement(qualifiedAccessExpression, data) } - open fun transformFunctionCall(functionCall: FirFunctionCall, data: D): CompositeTransformResult { + open fun transformFunctionCall(functionCall: FirFunctionCall, data: D): FirStatement { return transformElement(functionCall, data) } - open fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): CompositeTransformResult { + open fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): FirStatement { return transformElement(implicitInvokeCall, data) } - open fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult { + open fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): FirStatement { return transformElement(delegatedConstructorCall, data) } - open fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult { + open fun transformComponentCall(componentCall: FirComponentCall, data: D): FirStatement { return transformElement(componentCall, data) } - open fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): CompositeTransformResult { + open fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): FirStatement { return transformElement(callableReferenceAccess, data) } - open fun transformThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: D): CompositeTransformResult { + open fun transformThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: D): FirStatement { return transformElement(thisReceiverExpression, data) } - open fun transformExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): CompositeTransformResult { + open fun transformExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): FirStatement { return transformElement(expressionWithSmartcast, data) } - open fun transformSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: D): CompositeTransformResult { + open fun transformSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: D): FirStatement { return transformElement(safeCallExpression, data) } - open fun transformCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, data: D): CompositeTransformResult { + open fun transformCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, data: D): FirStatement { return transformElement(checkedSafeCallSubject, data) } - open fun transformGetClassCall(getClassCall: FirGetClassCall, data: D): CompositeTransformResult { + open fun transformGetClassCall(getClassCall: FirGetClassCall, data: D): FirStatement { return transformElement(getClassCall, data) } - open fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): CompositeTransformResult { + open fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): FirStatement { return transformElement(wrappedExpression, data) } - open fun transformWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): CompositeTransformResult { + open fun transformWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): FirStatement { return transformElement(wrappedArgumentExpression, data) } - open fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): CompositeTransformResult { + open fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): FirStatement { return transformElement(lambdaArgumentExpression, data) } - open fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): CompositeTransformResult { + open fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): FirStatement { return transformElement(spreadArgumentExpression, data) } - open fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult { + open fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): FirStatement { return transformElement(namedArgumentExpression, data) } - open fun transformVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: D): CompositeTransformResult { + open fun transformVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: D): FirStatement { return transformElement(varargArgumentsExpression, data) } - open fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): CompositeTransformResult { + open fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): FirStatement { return transformElement(resolvedQualifier, data) } - open fun transformErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: D): CompositeTransformResult { + open fun transformErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: D): FirStatement { return transformElement(errorResolvedQualifier, data) } - open fun transformResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, data: D): CompositeTransformResult { + open fun transformResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, data: D): FirStatement { return transformElement(resolvedReifiedParameterReference, data) } - open fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult { + open fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): FirStatement { return transformElement(returnExpression, data) } - open fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): CompositeTransformResult { + open fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): FirStatement { return transformElement(stringConcatenationCall, data) } - open fun transformThrowExpression(throwExpression: FirThrowExpression, data: D): CompositeTransformResult { + open fun transformThrowExpression(throwExpression: FirThrowExpression, data: D): FirStatement { return transformElement(throwExpression, data) } - open fun transformVariableAssignment(variableAssignment: FirVariableAssignment, data: D): CompositeTransformResult { + open fun transformVariableAssignment(variableAssignment: FirVariableAssignment, data: D): FirStatement { return transformElement(variableAssignment, data) } - open fun transformWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): CompositeTransformResult { + open fun transformWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): FirStatement { return transformElement(whenSubjectExpression, data) } - open fun transformWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): CompositeTransformResult { + open fun transformWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): FirStatement { return transformElement(wrappedDelegateExpression, data) } - open fun transformNamedReference(namedReference: FirNamedReference, data: D): CompositeTransformResult { + open fun transformNamedReference(namedReference: FirNamedReference, data: D): FirReference { return transformElement(namedReference, data) } - open fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): CompositeTransformResult { + open fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): FirReference { return transformElement(errorNamedReference, data) } - open fun transformSuperReference(superReference: FirSuperReference, data: D): CompositeTransformResult { + open fun transformSuperReference(superReference: FirSuperReference, data: D): FirReference { return transformElement(superReference, data) } - open fun transformThisReference(thisReference: FirThisReference, data: D): CompositeTransformResult { + open fun transformThisReference(thisReference: FirThisReference, data: D): FirReference { return transformElement(thisReference, data) } - open fun transformControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): CompositeTransformResult { + open fun transformControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): FirReference { return transformElement(controlFlowGraphReference, data) } - open fun transformResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, data: D): CompositeTransformResult { + open fun transformResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, data: D): FirReference { return transformElement(resolvedNamedReference, data) } - open fun transformDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): CompositeTransformResult { + open fun transformDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): FirReference { return transformElement(delegateFieldReference, data) } - open fun transformBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): CompositeTransformResult { + open fun transformBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): FirReference { return transformElement(backingFieldReference, data) } - open fun transformResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): CompositeTransformResult { + open fun transformResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): FirReference { return transformElement(resolvedCallableReference, data) } - open fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult { + open fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): FirTypeRef { return transformElement(resolvedTypeRef, data) } - open fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult { + open fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): FirTypeRef { return transformElement(errorTypeRef, data) } - open fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult { + open fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): FirTypeRef { return transformElement(typeRefWithNullability, data) } - open fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult { + open fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): FirTypeRef { return transformElement(userTypeRef, data) } - open fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult { + open fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): FirTypeRef { return transformElement(dynamicTypeRef, data) } - open fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult { + open fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): FirTypeRef { return transformElement(functionTypeRef, data) } - open fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult { + open fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): FirTypeRef { return transformElement(implicitTypeRef, data) } - open fun transformEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: D): CompositeTransformResult { + open fun transformEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: D): FirEffectDeclaration { return transformElement(effectDeclaration, data) } - open fun transformContractDescription(contractDescription: FirContractDescription, data: D): CompositeTransformResult { + open fun transformContractDescription(contractDescription: FirContractDescription, data: D): FirContractDescription { return transformElement(contractDescription, data) } - open fun transformLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription, data: D): CompositeTransformResult { + open fun transformLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription, data: D): FirContractDescription { return transformElement(legacyRawContractDescription, data) } - open fun transformRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): CompositeTransformResult { + open fun transformRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): FirContractDescription { return transformElement(rawContractDescription, data) } - open fun transformResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): CompositeTransformResult { + open fun transformResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): FirContractDescription { return transformElement(resolvedContractDescription, data) } - final override fun visitElement(element: FirElement, data: D): CompositeTransformResult { + final override fun visitElement(element: FirElement, data: D): FirElement { return transformElement(element, data) } - final override fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): CompositeTransformResult { + final override fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): FirAnnotationContainer { return transformAnnotationContainer(annotationContainer, data) } - final override fun visitTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult { + final override fun visitTypeRef(typeRef: FirTypeRef, data: D): FirTypeRef { return transformTypeRef(typeRef, data) } - final override fun visitReference(reference: FirReference, data: D): CompositeTransformResult { + final override fun visitReference(reference: FirReference, data: D): FirReference { return transformReference(reference, data) } - final override fun visitLabel(label: FirLabel, data: D): CompositeTransformResult { + final override fun visitLabel(label: FirLabel, data: D): FirLabel { return transformLabel(label, data) } - final override fun visitImport(import: FirImport, data: D): CompositeTransformResult { + final override fun visitImport(import: FirImport, data: D): FirImport { return transformImport(import, data) } - final override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: D): CompositeTransformResult { + final override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: D): FirImport { return transformResolvedImport(resolvedImport, data) } - final override fun visitSymbolOwner(symbolOwner: FirSymbolOwner, data: D): CompositeTransformResult> where E : FirSymbolOwner, E : FirDeclaration { + final override fun visitSymbolOwner(symbolOwner: FirSymbolOwner, data: D): FirSymbolOwner where E : FirSymbolOwner, E : FirDeclaration { return transformSymbolOwner(symbolOwner, data) } - final override fun visitResolvable(resolvable: FirResolvable, data: D): CompositeTransformResult { + final override fun visitResolvable(resolvable: FirResolvable, data: D): FirResolvable { return transformResolvable(resolvable, data) } - final override fun visitTargetElement(targetElement: FirTargetElement, data: D): CompositeTransformResult { + final override fun visitTargetElement(targetElement: FirTargetElement, data: D): FirTargetElement { return transformTargetElement(targetElement, data) } - final override fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): CompositeTransformResult { + final override fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): FirDeclarationStatus { return transformDeclarationStatus(declarationStatus, data) } - final override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): CompositeTransformResult { + final override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): FirDeclarationStatus { return transformResolvedDeclarationStatus(resolvedDeclarationStatus, data) } - final override fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: D): CompositeTransformResult { + final override fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: D): FirControlFlowGraphOwner { return transformControlFlowGraphOwner(controlFlowGraphOwner, data) } - final override fun visitStatement(statement: FirStatement, data: D): CompositeTransformResult { + final override fun visitStatement(statement: FirStatement, data: D): FirStatement { return transformStatement(statement, data) } - final override fun visitExpression(expression: FirExpression, data: D): CompositeTransformResult { + final override fun visitExpression(expression: FirExpression, data: D): FirStatement { return transformExpression(expression, data) } - final override fun visitDeclaration(declaration: FirDeclaration, data: D): CompositeTransformResult { + final override fun visitDeclaration(declaration: FirDeclaration, data: D): FirDeclaration { return transformDeclaration(declaration, data) } - final override fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): CompositeTransformResult { + final override fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): FirDeclaration { return transformAnnotatedDeclaration(annotatedDeclaration, data) } - final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): CompositeTransformResult { + final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): FirDeclaration { return transformAnonymousInitializer(anonymousInitializer, data) } - final override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): CompositeTransformResult { + final override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): FirDeclaration { return transformTypedDeclaration(typedDeclaration, data) } - final override fun > visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): CompositeTransformResult { + final override fun > visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): FirDeclaration { return transformCallableDeclaration(callableDeclaration, data) } - final override fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: D): CompositeTransformResult { + final override fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: D): FirTypeParameterRef { return transformTypeParameterRef(typeParameterRef, data) } - final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult { + final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): FirDeclaration { return transformTypeParameter(typeParameter, data) } - final override fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: D): CompositeTransformResult { + final override fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: D): FirTypeParameterRefsOwner { return transformTypeParameterRefsOwner(typeParameterRefsOwner, data) } - final override fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): CompositeTransformResult { + final override fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): FirTypeParametersOwner { return transformTypeParametersOwner(typeParametersOwner, data) } - final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): CompositeTransformResult { + final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): FirDeclaration { return transformMemberDeclaration(memberDeclaration, data) } - final override fun > visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): CompositeTransformResult { + final override fun > visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): FirDeclaration { return transformCallableMemberDeclaration(callableMemberDeclaration, data) } - final override fun > visitVariable(variable: FirVariable, data: D): CompositeTransformResult { + final override fun > visitVariable(variable: FirVariable, data: D): FirStatement { return transformVariable(variable, data) } - final override fun visitValueParameter(valueParameter: FirValueParameter, data: D): CompositeTransformResult { + final override fun visitValueParameter(valueParameter: FirValueParameter, data: D): FirStatement { return transformValueParameter(valueParameter, data) } - final override fun visitProperty(property: FirProperty, data: D): CompositeTransformResult { + final override fun visitProperty(property: FirProperty, data: D): FirDeclaration { return transformProperty(property, data) } - final override fun visitField(field: FirField, data: D): CompositeTransformResult { + final override fun visitField(field: FirField, data: D): FirDeclaration { return transformField(field, data) } - final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult { + final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): FirDeclaration { return transformEnumEntry(enumEntry, data) } - final override fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult { + final override fun > visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): FirStatement { return transformClassLikeDeclaration(classLikeDeclaration, data) } - final override fun > visitClass(klass: FirClass, data: D): CompositeTransformResult { + final override fun > visitClass(klass: FirClass, data: D): FirStatement { return transformClass(klass, data) } - final override fun visitRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult { + final override fun visitRegularClass(regularClass: FirRegularClass, data: D): FirStatement { return transformRegularClass(regularClass, data) } - final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult { + final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): FirDeclaration { return transformTypeAlias(typeAlias, data) } - final override fun > visitFunction(function: FirFunction, data: D): CompositeTransformResult { + final override fun > visitFunction(function: FirFunction, data: D): FirStatement { return transformFunction(function, data) } - final override fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): CompositeTransformResult { + final override fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: D): FirContractDescriptionOwner { return transformContractDescriptionOwner(contractDescriptionOwner, data) } - final override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: D): CompositeTransformResult { + final override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: D): FirDeclaration { return transformSimpleFunction(simpleFunction, data) } - final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult { + final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): FirDeclaration { return transformPropertyAccessor(propertyAccessor, data) } - final override fun visitConstructor(constructor: FirConstructor, data: D): CompositeTransformResult { + final override fun visitConstructor(constructor: FirConstructor, data: D): FirDeclaration { return transformConstructor(constructor, data) } - final override fun visitFile(file: FirFile, data: D): CompositeTransformResult { + final override fun visitFile(file: FirFile, data: D): FirDeclaration { return transformFile(file, data) } - final override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): CompositeTransformResult { + final override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): FirStatement { return transformAnonymousFunction(anonymousFunction, data) } - final override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: D): CompositeTransformResult { + final override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: D): FirStatement { return transformAnonymousObject(anonymousObject, data) } - final override fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): CompositeTransformResult { + final override fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): FirDiagnosticHolder { return transformDiagnosticHolder(diagnosticHolder, data) } - final override fun visitLoop(loop: FirLoop, data: D): CompositeTransformResult { + final override fun visitLoop(loop: FirLoop, data: D): FirStatement { return transformLoop(loop, data) } - final override fun visitErrorLoop(errorLoop: FirErrorLoop, data: D): CompositeTransformResult { + final override fun visitErrorLoop(errorLoop: FirErrorLoop, data: D): FirStatement { return transformErrorLoop(errorLoop, data) } - final override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): CompositeTransformResult { + final override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): FirStatement { return transformDoWhileLoop(doWhileLoop, data) } - final override fun visitWhileLoop(whileLoop: FirWhileLoop, data: D): CompositeTransformResult { + final override fun visitWhileLoop(whileLoop: FirWhileLoop, data: D): FirStatement { return transformWhileLoop(whileLoop, data) } - final override fun visitBlock(block: FirBlock, data: D): CompositeTransformResult { + final override fun visitBlock(block: FirBlock, data: D): FirStatement { return transformBlock(block, data) } - final override fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): CompositeTransformResult { + final override fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): FirStatement { return transformBinaryLogicExpression(binaryLogicExpression, data) } - final override fun visitJump(jump: FirJump, data: D): CompositeTransformResult { + final override fun visitJump(jump: FirJump, data: D): FirStatement { return transformJump(jump, data) } - final override fun visitLoopJump(loopJump: FirLoopJump, data: D): CompositeTransformResult { + final override fun visitLoopJump(loopJump: FirLoopJump, data: D): FirStatement { return transformLoopJump(loopJump, data) } - final override fun visitBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult { + final override fun visitBreakExpression(breakExpression: FirBreakExpression, data: D): FirStatement { return transformBreakExpression(breakExpression, data) } - final override fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult { + final override fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): FirStatement { return transformContinueExpression(continueExpression, data) } - final override fun visitCatch(catch: FirCatch, data: D): CompositeTransformResult { + final override fun visitCatch(catch: FirCatch, data: D): FirCatch { return transformCatch(catch, data) } - final override fun visitTryExpression(tryExpression: FirTryExpression, data: D): CompositeTransformResult { + final override fun visitTryExpression(tryExpression: FirTryExpression, data: D): FirStatement { return transformTryExpression(tryExpression, data) } - final override fun visitConstExpression(constExpression: FirConstExpression, data: D): CompositeTransformResult { + final override fun visitConstExpression(constExpression: FirConstExpression, data: D): FirStatement { return transformConstExpression(constExpression, data) } - final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult { + final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): FirTypeProjection { return transformTypeProjection(typeProjection, data) } - final override fun visitStarProjection(starProjection: FirStarProjection, data: D): CompositeTransformResult { + final override fun visitStarProjection(starProjection: FirStarProjection, data: D): FirTypeProjection { return transformStarProjection(starProjection, data) } - final override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): CompositeTransformResult { + final override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): FirTypeProjection { return transformTypeProjectionWithVariance(typeProjectionWithVariance, data) } - final override fun visitArgumentList(argumentList: FirArgumentList, data: D): CompositeTransformResult { + final override fun visitArgumentList(argumentList: FirArgumentList, data: D): FirArgumentList { return transformArgumentList(argumentList, data) } - final override fun visitCall(call: FirCall, data: D): CompositeTransformResult { + final override fun visitCall(call: FirCall, data: D): FirStatement { return transformCall(call, data) } - final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult { + final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement { return transformAnnotationCall(annotationCall, data) } - final override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): CompositeTransformResult { + final override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): FirStatement { return transformComparisonExpression(comparisonExpression, data) } - final override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): CompositeTransformResult { + final override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): FirStatement { return transformTypeOperatorCall(typeOperatorCall, data) } - final override fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: D): CompositeTransformResult { + final override fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: D): FirStatement { return transformAssignmentOperatorStatement(assignmentOperatorStatement, data) } - final override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: D): CompositeTransformResult { + final override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: D): FirStatement { return transformEqualityOperatorCall(equalityOperatorCall, data) } - final override fun visitWhenExpression(whenExpression: FirWhenExpression, data: D): CompositeTransformResult { + final override fun visitWhenExpression(whenExpression: FirWhenExpression, data: D): FirStatement { return transformWhenExpression(whenExpression, data) } - final override fun visitWhenBranch(whenBranch: FirWhenBranch, data: D): CompositeTransformResult { + final override fun visitWhenBranch(whenBranch: FirWhenBranch, data: D): FirWhenBranch { return transformWhenBranch(whenBranch, data) } - final override fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): CompositeTransformResult { + final override fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): FirStatement { return transformQualifiedAccess(qualifiedAccess, data) } - final override fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): CompositeTransformResult { + final override fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): FirStatement { return transformCheckNotNullCall(checkNotNullCall, data) } - final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: D): CompositeTransformResult { + final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: D): FirStatement { return transformElvisExpression(elvisExpression, data) } - final override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult { + final override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): FirStatement { return transformArrayOfCall(arrayOfCall, data) } - final override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): CompositeTransformResult { + final override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): FirStatement { return transformAugmentedArraySetCall(augmentedArraySetCall, data) } - final override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult { + final override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): FirStatement { return transformClassReferenceExpression(classReferenceExpression, data) } - final override fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult { + final override fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): FirStatement { return transformErrorExpression(errorExpression, data) } - final override fun visitErrorFunction(errorFunction: FirErrorFunction, data: D): CompositeTransformResult { + final override fun visitErrorFunction(errorFunction: FirErrorFunction, data: D): FirStatement { return transformErrorFunction(errorFunction, data) } - final override fun visitErrorProperty(errorProperty: FirErrorProperty, data: D): CompositeTransformResult { + final override fun visitErrorProperty(errorProperty: FirErrorProperty, data: D): FirStatement { return transformErrorProperty(errorProperty, data) } - final override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): CompositeTransformResult { + final override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): FirStatement { return transformQualifiedAccessExpression(qualifiedAccessExpression, data) } - final override fun visitFunctionCall(functionCall: FirFunctionCall, data: D): CompositeTransformResult { + final override fun visitFunctionCall(functionCall: FirFunctionCall, data: D): FirStatement { return transformFunctionCall(functionCall, data) } - final override fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): CompositeTransformResult { + final override fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): FirStatement { return transformImplicitInvokeCall(implicitInvokeCall, data) } - final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult { + final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): FirStatement { return transformDelegatedConstructorCall(delegatedConstructorCall, data) } - final override fun visitComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult { + final override fun visitComponentCall(componentCall: FirComponentCall, data: D): FirStatement { return transformComponentCall(componentCall, data) } - final override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): CompositeTransformResult { + final override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): FirStatement { return transformCallableReferenceAccess(callableReferenceAccess, data) } - final override fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: D): CompositeTransformResult { + final override fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: D): FirStatement { return transformThisReceiverExpression(thisReceiverExpression, data) } - final override fun visitExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): CompositeTransformResult { + final override fun visitExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): FirStatement { return transformExpressionWithSmartcast(expressionWithSmartcast, data) } - final override fun visitSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: D): CompositeTransformResult { + final override fun visitSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: D): FirStatement { return transformSafeCallExpression(safeCallExpression, data) } - final override fun visitCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, data: D): CompositeTransformResult { + final override fun visitCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, data: D): FirStatement { return transformCheckedSafeCallSubject(checkedSafeCallSubject, data) } - final override fun visitGetClassCall(getClassCall: FirGetClassCall, data: D): CompositeTransformResult { + final override fun visitGetClassCall(getClassCall: FirGetClassCall, data: D): FirStatement { return transformGetClassCall(getClassCall, data) } - final override fun visitWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): CompositeTransformResult { + final override fun visitWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): FirStatement { return transformWrappedExpression(wrappedExpression, data) } - final override fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): CompositeTransformResult { + final override fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): FirStatement { return transformWrappedArgumentExpression(wrappedArgumentExpression, data) } - final override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): CompositeTransformResult { + final override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): FirStatement { return transformLambdaArgumentExpression(lambdaArgumentExpression, data) } - final override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): CompositeTransformResult { + final override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): FirStatement { return transformSpreadArgumentExpression(spreadArgumentExpression, data) } - final override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult { + final override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): FirStatement { return transformNamedArgumentExpression(namedArgumentExpression, data) } - final override fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: D): CompositeTransformResult { + final override fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: D): FirStatement { return transformVarargArgumentsExpression(varargArgumentsExpression, data) } - final override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): CompositeTransformResult { + final override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): FirStatement { return transformResolvedQualifier(resolvedQualifier, data) } - final override fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: D): CompositeTransformResult { + final override fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: D): FirStatement { return transformErrorResolvedQualifier(errorResolvedQualifier, data) } - final override fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, data: D): CompositeTransformResult { + final override fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, data: D): FirStatement { return transformResolvedReifiedParameterReference(resolvedReifiedParameterReference, data) } - final override fun visitReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult { + final override fun visitReturnExpression(returnExpression: FirReturnExpression, data: D): FirStatement { return transformReturnExpression(returnExpression, data) } - final override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): CompositeTransformResult { + final override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): FirStatement { return transformStringConcatenationCall(stringConcatenationCall, data) } - final override fun visitThrowExpression(throwExpression: FirThrowExpression, data: D): CompositeTransformResult { + final override fun visitThrowExpression(throwExpression: FirThrowExpression, data: D): FirStatement { return transformThrowExpression(throwExpression, data) } - final override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: D): CompositeTransformResult { + final override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: D): FirStatement { return transformVariableAssignment(variableAssignment, data) } - final override fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): CompositeTransformResult { + final override fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): FirStatement { return transformWhenSubjectExpression(whenSubjectExpression, data) } - final override fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): CompositeTransformResult { + final override fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): FirStatement { return transformWrappedDelegateExpression(wrappedDelegateExpression, data) } - final override fun visitNamedReference(namedReference: FirNamedReference, data: D): CompositeTransformResult { + final override fun visitNamedReference(namedReference: FirNamedReference, data: D): FirReference { return transformNamedReference(namedReference, data) } - final override fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): CompositeTransformResult { + final override fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): FirReference { return transformErrorNamedReference(errorNamedReference, data) } - final override fun visitSuperReference(superReference: FirSuperReference, data: D): CompositeTransformResult { + final override fun visitSuperReference(superReference: FirSuperReference, data: D): FirReference { return transformSuperReference(superReference, data) } - final override fun visitThisReference(thisReference: FirThisReference, data: D): CompositeTransformResult { + final override fun visitThisReference(thisReference: FirThisReference, data: D): FirReference { return transformThisReference(thisReference, data) } - final override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): CompositeTransformResult { + final override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): FirReference { return transformControlFlowGraphReference(controlFlowGraphReference, data) } - final override fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, data: D): CompositeTransformResult { + final override fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, data: D): FirReference { return transformResolvedNamedReference(resolvedNamedReference, data) } - final override fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): CompositeTransformResult { + final override fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): FirReference { return transformDelegateFieldReference(delegateFieldReference, data) } - final override fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): CompositeTransformResult { + final override fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): FirReference { return transformBackingFieldReference(backingFieldReference, data) } - final override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): CompositeTransformResult { + final override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): FirReference { return transformResolvedCallableReference(resolvedCallableReference, data) } - final override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult { + final override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): FirTypeRef { return transformResolvedTypeRef(resolvedTypeRef, data) } - final override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult { + final override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): FirTypeRef { return transformErrorTypeRef(errorTypeRef, data) } - final override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult { + final override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): FirTypeRef { return transformTypeRefWithNullability(typeRefWithNullability, data) } - final override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult { + final override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: D): FirTypeRef { return transformUserTypeRef(userTypeRef, data) } - final override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult { + final override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): FirTypeRef { return transformDynamicTypeRef(dynamicTypeRef, data) } - final override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult { + final override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): FirTypeRef { return transformFunctionTypeRef(functionTypeRef, data) } - final override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult { + final override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): FirTypeRef { return transformImplicitTypeRef(implicitTypeRef, data) } - final override fun visitEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: D): CompositeTransformResult { + final override fun visitEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: D): FirEffectDeclaration { return transformEffectDeclaration(effectDeclaration, data) } - final override fun visitContractDescription(contractDescription: FirContractDescription, data: D): CompositeTransformResult { + final override fun visitContractDescription(contractDescription: FirContractDescription, data: D): FirContractDescription { return transformContractDescription(contractDescription, data) } - final override fun visitLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription, data: D): CompositeTransformResult { + final override fun visitLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription, data: D): FirContractDescription { return transformLegacyRawContractDescription(legacyRawContractDescription, data) } - final override fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): CompositeTransformResult { + final override fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): FirContractDescription { return transformRawContractDescription(rawContractDescription, data) } - final override fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): CompositeTransformResult { + final override fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): FirContractDescription { return transformResolvedContractDescription(resolvedContractDescription, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt deleted file mode 100644 index fc78ff8496c..00000000000 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt +++ /dev/null @@ -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 { - - class Single(val _single: T) : CompositeTransformResult() - - class Multiple(val _list: List) : CompositeTransformResult() - - companion object { - fun empty() = Multiple(emptyList()) - fun single(t: T) = Single(t) - fun many(l: List) = Multiple(l) - } - - @Suppress("UNCHECKED_CAST") - val list: List - get() = when (this) { - is Multiple<*> -> _list as List - 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.compose() = CompositeTransformResult.single(this) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt index 9234f8827dd..23c76cc8f96 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt @@ -12,94 +12,94 @@ import org.jetbrains.kotlin.fir.references.FirReference import org.jetbrains.kotlin.fir.types.* abstract class FirDefaultTransformer : FirTransformer() { - override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult { + override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): FirTypeRef { return transformTypeRef(implicitTypeRef, data) } - override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult { + override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): FirTypeRef { return transformTypeRef(resolvedTypeRef, data) } - override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult { + override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): FirTypeRef { return transformResolvedTypeRef(errorTypeRef, data) } - override fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult { + override fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): FirTypeRef { return transformTypeRef(typeRefWithNullability, data) } - override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult { + override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): FirTypeRef { return transformTypeRefWithNullability(dynamicTypeRef, data) } - override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult { + override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): FirTypeRef { return transformTypeRefWithNullability(functionTypeRef, data) } - override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult { + override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): FirTypeRef { return transformTypeRefWithNullability(userTypeRef, data) } override fun transformCallableReferenceAccess( callableReferenceAccess: FirCallableReferenceAccess, data: D - ): CompositeTransformResult { + ): FirStatement { return transformQualifiedAccessExpression(callableReferenceAccess, data) } - override fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult { + override fun transformComponentCall(componentCall: FirComponentCall, data: D): FirStatement { return transformFunctionCall(componentCall, data) } - override fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult { + override fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): FirStatement { return transformJump(returnExpression, data) } - override fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult { + override fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): FirStatement { return transformJump(continueExpression, data) } - override fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult { + override fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): FirStatement { return transformJump(breakExpression, data) } - override fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): CompositeTransformResult { + override fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): FirStatement { return transformWrappedArgumentExpression(lambdaArgumentExpression, data) } - override fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): CompositeTransformResult { + override fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): FirStatement { return transformWrappedArgumentExpression(spreadArgumentExpression, data) } - override fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult { + override fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): FirStatement { return transformWrappedArgumentExpression(namedArgumentExpression, data) } - override fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult { + override fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): FirStatement { return transformExpression(errorExpression, data) } - override fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): CompositeTransformResult { + override fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): FirStatement { return transformLoop(errorLoop, data) } - override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): CompositeTransformResult { + override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): FirReference { return transformNamedReference(errorNamedReference, data) } - override fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): CompositeTransformResult { + override fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): FirStatement { return transformFunction(errorFunction, data) } override fun transformErrorResolvedQualifier( errorResolvedQualifier: FirErrorResolvedQualifier, data: D - ): CompositeTransformResult { + ): FirStatement { return transformResolvedQualifier(errorResolvedQualifier, data) } - override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): CompositeTransformResult { + override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): FirStatement { return transformFunctionCall(implicitInvokeCall, data) } } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformerUtil.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformerUtil.kt index 80589c546f1..8be46c99a60 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformerUtil.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformerUtil.kt @@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirPureAbstractElement fun T.transformSingle(transformer: FirTransformer, data: D): T { - return (this as FirPureAbstractElement).transform(transformer, data).single + return (this as FirPureAbstractElement).transform(transformer, data) } fun MutableList.transformInplace(transformer: FirTransformer, data: D) { @@ -17,20 +17,7 @@ fun MutableList.transformInplace(transformer: FirTransfor while (iterator.hasNext()) { val next = iterator.next() as FirPureAbstractElement val result = next.transform(transformer, data) - if (result.isSingle) { - 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()) - } - } - + iterator.set(result) } } @@ -48,7 +35,7 @@ inline fun MutableList.transformInplace(transformer: FirT is TransformData.Data -> data.value TransformData.Nothing -> continue } - val result = next.transform(transformer, data).single + val result = next.transform(transformer, data) iterator.set(result) } } diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt index 2cabe3c7b83..c819ce20b3b 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt @@ -60,7 +60,6 @@ val implicitStringTypeRefType = generatedType("types.impl", "FirImplicitStringTy val implicitUnitTypeRefType = generatedType("types.impl", "FirImplicitUnitTypeRef") val resolvePhaseType = type("fir.declarations", "FirResolvePhase") val stubReferenceType = generatedType("references.impl", "FirStubReference") -val compositeTransformResultType = type("fir.visitors", "CompositeTransformResult") val abstractFirBasedSymbolType = type("fir.symbols", "AbstractFirBasedSymbol") val backingFieldSymbolType = type("fir.symbols.impl", "FirBackingFieldSymbol") diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt index 5bee9be927d..98c3455e6e6 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt @@ -133,9 +133,9 @@ fun SmartPrinter.printElement(element: Element) { println("fun acceptChildren(visitor: FirVisitorVoid) = acceptChildren(visitor, null)") println() println("@Suppress(\"UNCHECKED_CAST\")") - println("fun transform(visitor: FirTransformer, data: D): CompositeTransformResult =") + println("fun transform(visitor: FirTransformer, data: D): E =") withIndent { - println("accept(visitor, data) as CompositeTransformResult") + println("accept(visitor, data) as E") } println() println("fun transformChildren(transformer: FirTransformer, data: D): FirElement") diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt index 02f79ac1f6f..17393d06b3d 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt @@ -5,7 +5,6 @@ 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.model.Element import org.jetbrains.kotlin.util.SmartPrinter @@ -22,14 +21,13 @@ fun printTransformer(elements: List, generationPath: File): GeneratedFi println("package $VISITOR_PACKAGE") println() elements.forEach { println("import ${it.fullQualifiedName}") } - println("import ${compositeTransformResultType.fullQualifiedName}") println() printGeneratedMessage() - println("abstract class FirTransformer : FirVisitor, D>() {") + println("abstract class FirTransformer : FirVisitor() {") println() withIndent { - println("abstract fun transformElement(element: E, data: D): CompositeTransformResult") + println("abstract fun transformElement(element: E, data: D): E") println() for (element in elements) { if (element == AbstractFirTreeBuilder.baseFirElement) continue @@ -37,8 +35,8 @@ fun printTransformer(elements: List, generationPath: File): GeneratedFi print("open fun ") element.typeParameters.takeIf { it.isNotBlank() }?.let { print(it) } println( - "transform${element.name}($varName: ${element.typeWithArguments}, data: D): CompositeTransformResult<${element.transformerType - .typeWithArguments}>${element.multipleUpperBoundsList()}{", + "transform${element.name}($varName: ${element.typeWithArguments}, data: D): ${element.transformerType + .typeWithArguments}${element.multipleUpperBoundsList()}{", ) withIndent { println("return transformElement($varName, data)") @@ -53,8 +51,8 @@ fun printTransformer(elements: List, generationPath: File): GeneratedFi element.typeParameters.takeIf { it.isNotBlank() }?.let { print(it) } println( - "visit${element.name}($varName: ${element.typeWithArguments}, data: D): CompositeTransformResult<${element.transformerType - .typeWithArguments}>${element.multipleUpperBoundsList()}{", + "visit${element.name}($varName: ${element.typeWithArguments}, data: D): ${element.transformerType + .typeWithArguments}${element.multipleUpperBoundsList()}{", ) withIndent { println("return transform${element.name}($varName, data)") diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/utils.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/utils.kt index bcd6e5749c6..cc757d38f58 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/utils.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/utils.kt @@ -5,7 +5,6 @@ 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.firImplementationDetailType import org.jetbrains.kotlin.fir.tree.generator.model.* @@ -52,10 +51,6 @@ fun Implementation.collectImports(base: List = emptyList(), kind: Import fun Element.collectImports(): List { val baseTypes = parents.mapTo(mutableListOf()) { it.fullQualifiedName } baseTypes += parentsArguments.values.flatMap { it.values }.mapNotNull { it.fullQualifiedName } - val isBaseFirElement = this == AbstractFirTreeBuilder.baseFirElement - if (isBaseFirElement) { - baseTypes += compositeTransformResultType.fullQualifiedName!! - } if (needPureAbstractElement) { baseTypes += pureAbstractElementType.fullQualifiedName!! } diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/element/builder/FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator.kt b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/element/builder/FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator.kt index 8d64bde7050..cd3fd4b5846 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/element/builder/FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator.kt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/element/builder/FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator.kt @@ -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.FirDesignatedBodyResolveTransformerForReturnTypeCalculator 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 fun FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator( @@ -61,17 +60,17 @@ class FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl( override fun transformSimpleFunction( simpleFunction: FirSimpleFunction, data: ResolutionMode - ): CompositeTransformResult { + ): FirSimpleFunction { FirLazyBodiesCalculator.calculateLazyBodiesForFunction(simpleFunction, declarationDesignation) return super.transformSimpleFunction(simpleFunction, data) } - override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult { + override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration { FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(constructor, declarationDesignation) return super.transformConstructor(constructor, data) } - override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty { FirLazyBodiesCalculator.calculateLazyBodyForProperty(property, declarationDesignation) return super.transformProperty(property, data) } diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyBodiesCalculator.kt b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyBodiesCalculator.kt index a802876871d..3ef61efb71e 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyBodiesCalculator.kt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyBodiesCalculator.kt @@ -101,14 +101,14 @@ internal object FirLazyBodiesCalculator { private object FirLazyBodiesCalculatorTransformer : FirTransformer>() { - override fun transformFile(file: FirFile, data: MutableList): CompositeTransformResult { + override fun transformFile(file: FirFile, data: MutableList): FirDeclaration { file.declarations.forEach { it.transformSingle(this, data) } - return file.compose() + return file } - override fun transformElement(element: E, data: MutableList): CompositeTransformResult { + override fun transformElement(element: E, data: MutableList): E { if (element is FirRegularClass) { data.add(element) element.declarations.forEach { @@ -117,33 +117,33 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer - ): CompositeTransformResult { + ): FirDeclaration { if (simpleFunction.body is FirLazyBlock) { FirLazyBodiesCalculator.calculateLazyBodiesForFunction(simpleFunction, data) } - return simpleFunction.compose() + return simpleFunction } override fun transformConstructor( constructor: FirConstructor, data: MutableList - ): CompositeTransformResult { + ): FirDeclaration { if (constructor.body is FirLazyBlock) { FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(constructor, data) } - return constructor.compose() + return constructor } - override fun transformProperty(property: FirProperty, data: MutableList): CompositeTransformResult { + override fun transformProperty(property: FirProperty, data: MutableList): FirDeclaration { if (FirLazyBodiesCalculator.needCalculatingLazyBodyForProperty(property)) { FirLazyBodiesCalculator.calculateLazyBodyForProperty(property, data) } - return property.compose() + return property } } diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedBodyResolveTransformerForIDE.kt b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedBodyResolveTransformerForIDE.kt index db61084f65d..b3485ca5c38 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedBodyResolveTransformerForIDE.kt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedBodyResolveTransformerForIDE.kt @@ -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.ImplicitBodyResolveComputationSession 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.FirTowerDataContextCollector @@ -40,7 +38,7 @@ internal class FirDesignatedBodyResolveTransformerForIDE( private val ideDeclarationTransformer = IDEDeclarationTransformer(designation) @Suppress("NAME_SHADOWING") - override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult = + override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration = ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data -> super.transformDeclarationContent(declaration, data) } diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedContractsResolveTransformerForIDE.kt b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedContractsResolveTransformerForIDE.kt index 16518ffaa16..a5af6911d8c 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedContractsResolveTransformerForIDE.kt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedContractsResolveTransformerForIDE.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveTransformer -import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult internal class FirDesignatedContractsResolveTransformerForIDE( designation: FirDesignation, @@ -20,7 +19,7 @@ internal class FirDesignatedContractsResolveTransformerForIDE( private val ideDeclarationTransformer = IDEDeclarationTransformer(designation) @Suppress("NAME_SHADOWING") - override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult = + override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration = ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data -> super.transformDeclarationContent(declaration, data) } diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedImplicitTypesTransformerForIDE.kt b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedImplicitTypesTransformerForIDE.kt index 96dcf25c901..c791b5e24af 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedImplicitTypesTransformerForIDE.kt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirDesignatedImplicitTypesTransformerForIDE.kt @@ -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.ImplicitBodyResolveComputationSession 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.FirTowerDataContextCollector @@ -41,7 +39,7 @@ internal class FirDesignatedImplicitTypesTransformerForIDE( private val ideDeclarationTransformer = IDEDeclarationTransformer(designation) @Suppress("NAME_SHADOWING") - override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult = + override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration = ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data -> super.transformDeclarationContent(declaration, data) } diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirFileAnnotationsResolveTransformer.kt b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirFileAnnotationsResolveTransformer.kt index f4293de8401..aeac0effb5b 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirFileAnnotationsResolveTransformer.kt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/FirFileAnnotationsResolveTransformer.kt @@ -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.ImplicitBodyResolveComputationSession 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 internal class FirFileAnnotationsResolveTransformer( @@ -29,10 +27,10 @@ internal class FirFileAnnotationsResolveTransformer( ::FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator ), ) { - override fun transformFile(file: FirFile, data: ResolutionMode): CompositeTransformResult { + override fun transformFile(file: FirFile, data: ResolutionMode): FirFile { return context.withFile(file, components) { file.transformAnnotations(this, data) - file.compose() + file } } diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/IDEDeclarationTransformer.kt b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/IDEDeclarationTransformer.kt index dad35d78fdf..2c1c13bfeb2 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/IDEDeclarationTransformer.kt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/trasformers/IDEDeclarationTransformer.kt @@ -10,10 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.resolve.ResolutionMode 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.compose -import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.PrivateForInline internal class IDEDeclarationTransformer(private val designation: FirDesignation) { private var isInsideTargetDeclaration: Boolean = false @@ -32,8 +29,8 @@ internal class IDEDeclarationTransformer(private val designation: FirDesignation transformer: FirAbstractBodyResolveTransformer, declaration: FirDeclaration, data: ResolutionMode, - transformDeclaration: (FirDeclaration, ResolutionMode) -> CompositeTransformResult - ): CompositeTransformResult { + transformDeclaration: (FirDeclaration, ResolutionMode) -> FirDeclaration + ): FirDeclaration { return if (designation.canGoNext()) { val declarationToTransform = designation.currentDeclaration val isTargetDeclaration = designation.isTargetDeclaration() @@ -41,12 +38,12 @@ internal class IDEDeclarationTransformer(private val designation: FirDesignation insideTargetDeclaration(isTargetDeclaration) { declarationToTransform.visitNoTransform(transformer, data) } - declaration.compose() + declaration } else { if (isInsideTargetDeclaration) { transformDeclaration(declaration, data) } else { - declaration.compose() + declaration } } } @@ -57,5 +54,5 @@ internal class IDEDeclarationTransformer(private val designation: FirDesignation private fun FirElement.visitNoTransform(transformer: FirTransformer, data: D) { val result = this.transform(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()}`" } }