FIR: Get rid of CompositeTransformResult

2021-04-09 16:38:44 +02:00
parent 00df2c4a9e
commit dfd5e80ce9
52 changed files with 913 additions and 1108 deletions
@@ -1,50 +1,4 @@
 FILE: transform.kt
-    public sealed class CompositeTransformResult<out T : R|kotlin/Any|> : R|kotlin/Any| {
-        protected constructor<out T : R|kotlin/Any|>(): R|CompositeTransformResult<T>| {
-            super<R|kotlin/Any|>()
-        }
-
-        public final class Single<out T : R|kotlin/Any|> : R|CompositeTransformResult<T>| {
-            public constructor<out T : R|kotlin/Any|>(_single: R|T|): R|CompositeTransformResult.Single<T>| {
-                super<R|CompositeTransformResult<T>|>()
-            }
-
-            public final val _single: R|T| = R|<local>/_single|
-                public get(): R|T|
-
-        }
-
-        public final class Multiple<out T : R|kotlin/Any|> : R|CompositeTransformResult<T>| {
-            public constructor<out T : R|kotlin/Any|>(_list: R|kotlin/collections/List<T>|): R|CompositeTransformResult.Multiple<T>| {
-                super<R|CompositeTransformResult<T>|>()
-            }
-
-            public final val _list: R|kotlin/collections/List<T>| = R|<local>/_list|
-                public get(): R|kotlin/collections/List<T>|
-
-        }
-
-        public final companion object Companion : R|kotlin/Any| {
-            private constructor(): R|CompositeTransformResult.Companion| {
-                super<R|kotlin/Any|>()
-            }
-
-            public final fun <T : R|kotlin/Any|> single(t: R|T|): R|CompositeTransformResult.Single<T>| {
-                ^single R|SubstitutionOverride</CompositeTransformResult.Single.Single>|<R|T|>(R|<local>/t|)
-            }
-
-            public final fun <T : R|kotlin/Any|> many(l: R|kotlin/collections/List<T>|): R|CompositeTransformResult.Multiple<T>| {
-                ^many R|SubstitutionOverride</CompositeTransformResult.Multiple.Multiple>|<R|T|>(R|<local>/l|)
-            }
-
-        }
-
-        public final val single: R|T|
-            public get(): R|T| {
-                ^ ((this@R|/CompositeTransformResult| as R|CompositeTransformResult.Single<*>|).R|SubstitutionOverride</CompositeTransformResult.Single._single: R|CapturedType(*)|>| as R|T|)
-            }
-
-    }
    public abstract interface FirElement : R|kotlin/Any| {
        public abstract fun <R, D> accept(visitor: R|FirVisitor<R, D>|, data: R|D|): R|R|

@@ -52,7 +6,7 @@ FILE: transform.kt
            ^accept this@R|/FirElement|.R|/FirElement.accept|<R|kotlin/Unit|, R|kotlin/Nothing?|>(R|<local>/visitor|, Null(null))
        }

-        public abstract fun <E : R|FirElement|, D> transform(visitor: R|FirTransformer<D>|, data: R|D|): R|CompositeTransformResult<E>|
+        public abstract fun <E : R|FirElement|, D> transform(visitor: R|FirTransformer<D>|, data: R|D|): R|E|

    }
    public abstract class FirVisitor<out R, in D> : R|kotlin/Any| {
@@ -67,9 +21,9 @@ FILE: transform.kt
        }

    }
-    public abstract class FirTransformer<in D> : R|FirVisitor<CompositeTransformResult<FirElement>, D>| {
+    public abstract class FirTransformer<in D> : R|FirVisitor<FirElement, D>| {
        public constructor<in D>(): R|FirTransformer<D>| {
-            super<R|FirVisitor<CompositeTransformResult<FirElement>, D>|>()
+            super<R|FirVisitor<FirElement, D>|>()
        }

    }
@@ -109,7 +63,7 @@ FILE: transform.kt
    }
    public final fun <F : R|FirClass<F>|> R|F|.runSupertypeResolvePhaseForLocalClass(): R|F| {
        lval applySupertypesTransformer: R|FirApplySupertypesTransformer| = R|/FirApplySupertypesTransformer.FirApplySupertypesTransformer|()
-        ^runSupertypeResolvePhaseForLocalClass this@R|/runSupertypeResolvePhaseForLocalClass|.R|SubstitutionOverride</FirClass.transform: R|CompositeTransformResult<E>|>|<R|F|, R|kotlin/Nothing?|>(R|<local>/applySupertypesTransformer|, Null(null)).R|SubstitutionOverride</CompositeTransformResult.single: R|F|>|
+        ^runSupertypeResolvePhaseForLocalClass this@R|/runSupertypeResolvePhaseForLocalClass|.R|SubstitutionOverride</FirClass.transform: R|E|>|<R|F|, R|kotlin/Nothing?|>(R|<local>/applySupertypesTransformer|, Null(null))
    }
    public abstract class FirPureAbstractElement : R|FirElement| {
        public constructor(): R|FirPureAbstractElement| {
@@ -1,31 +1,16 @@
-sealed class CompositeTransformResult<out T : Any> {
-
-    class Single<out T : Any>(val _single: T) : CompositeTransformResult<T>()
-
-    class Multiple<out T : Any>(val _list: List<T>) : CompositeTransformResult<T>()
-
-    companion object {
-        fun <T : Any> single(t: T) = Single(t)
-        fun <T : Any> many(l: List<T>) = Multiple(l)
-    }
-
-    val single: T
-        get() = (this as Single<*>)._single as T
-}
-
 interface FirElement {
    fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R

    fun accept(visitor: FirVisitorVoid) = accept(visitor, null)

-    fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): CompositeTransformResult<E>
+    fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): E
 }

 abstract class FirVisitor<out R, in D>

 abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>()

-abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirElement>, D>()
+abstract class FirTransformer<in D> : FirVisitor<FirElement, D>()

 interface FirAnnotationContainer : FirElement {
    abstract override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R
@@ -59,7 +44,7 @@ private class FirApplySupertypesTransformer() : FirTransformer<Nothing?>()

 fun <F : FirClass<F>> F.runSupertypeResolvePhaseForLocalClass(): F {
    val applySupertypesTransformer = FirApplySupertypesTransformer()
-    return this.transform<F, Nothing?>(applySupertypesTransformer, null).single
+    return this.transform<F, Nothing?>(applySupertypesTransformer, null)
 }

 abstract class FirPureAbstractElement : FirElement
@@ -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<Nothing?>() {
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        return element
    }

-    override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+    override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
        diagnosticCollector.collectDiagnostics(file)
-        return file.compose()
+        return file
    }
 }
@@ -28,7 +28,6 @@ import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.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<Unit>() {
        var result = hashSetOf<FirElement>()

-        override fun <E : FirElement> transformElement(element: E, data: Unit): CompositeTransformResult<E> {
+        override fun <E : FirElement> transformElement(element: E, data: Unit): E {
            if (!result.add(element)) {
                throwTwiceVisitingError(element)
            } else {
                element.transformChildren(this, Unit)
            }
-            return CompositeTransformResult.single(element)
+            return element
        }
    }

@@ -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<Nothing?>() {

-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
        @Suppress("UNCHECKED_CAST")
-        return (element.transformChildren(this, data) as E).compose()
+        return (element.transformChildren(this, data) as E)
    }

-    override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> =
+    override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?): FirTypeRef =
        substitutor.substituteOrNull(resolvedTypeRef.type)?.let {
-            resolvedTypeRef.withReplacedConeType(it).compose()
-        } ?: resolvedTypeRef.compose()
+            resolvedTypeRef.withReplacedConeType(it)
+        } ?: resolvedTypeRef

-    override fun transformArgumentList(argumentList: FirArgumentList, data: Nothing?): CompositeTransformResult<FirArgumentList> =
-        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)
@@ -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<D>(
@@ -27,15 +25,15 @@ abstract class FirAbstractPhaseTransformer<D>(
        }
    }

-    override fun transformFile(file: FirFile, data: D): CompositeTransformResult<FirFile> {
+    override fun transformFile(file: FirFile, data: D): FirFile {
        checkSessionConsistency(file)
        file.replaceResolvePhase(transformerPhase)

        @Suppress("UNCHECKED_CAST")
-        return super.transformFile(file, data) as CompositeTransformResult<FirFile>
+        return super.transformFile(file, data) as FirFile
    }

-    override fun transformDeclaration(declaration: FirDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
+    override fun transformDeclaration(declaration: FirDeclaration, data: D): FirDeclaration {
        declaration.replaceResolvePhase(transformerPhase)

        return super.transformDeclaration(declaration, data)
@@ -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<D>(phase: FirResolvePhase) : FirAbstractPhaseTransformer<D>(phase) {
-    override fun <E : FirElement> transformElement(element: E, data: D): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: D): E {
        @Suppress("UNCHECKED_CAST")
-        return (element.transformChildren(this, data) as E).compose()
+        return (element.transformChildren(this, data) as E)
    }
 }
@@ -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> {
+    ): FirStatement {
        firClass.replaceResolvePhase(transformerPhase)
        return withScopeCleanup {
            // Otherwise annotations may try to resolve
@@ -123,14 +123,14 @@ class FirCallCompletionResultsWriterTransformer(
    override fun transformQualifiedAccessExpression(
        qualifiedAccessExpression: FirQualifiedAccessExpression,
        data: ExpectedArgumentType?,
-    ): CompositeTransformResult<FirStatement> {
+    ): 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<FirStatement> {
+    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> {
+    ): 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> {
+    ): 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> {
+    ): 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> {
+    ): 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<Nothing?>() {
-        override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-            return element.compose()
+        override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+            return element
        }

        override fun transformQualifiedAccessExpression(
            qualifiedAccessExpression: FirQualifiedAccessExpression,
            data: Nothing?
-        ): CompositeTransformResult<FirStatement> {
+        ): 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> {
+    ): 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> {
+    ): 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<FirElement, ExpectedArgumentType?>(this, finalType?.toExpectedType())
        }

-        val resultFunction = result.single
+        val resultFunction = result
        if (resultFunction.returnTypeRef.coneTypeSafe<ConeIntegerLiteralType>() != null) {
            val lastExpressionType =
                (returnExpressionsOfAnonymousFunction.lastOrNull() as? FirExpression)
@@ -563,44 +562,44 @@ class FirCallCompletionResultsWriterTransformer(

    private fun transformImplicitTypeRefInAnonymousFunction(
        anonymousFunction: FirAnonymousFunction
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        val implicitTypeTransformer = object : FirDefaultTransformer<Nothing?>() {
-            override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
+            override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
                @Suppress("UNCHECKED_CAST")
-                return (element.transformChildren(this, data) as E).compose()
+                return (element.transformChildren(this, data) as E)
            }

            override fun transformImplicitTypeRef(
                implicitTypeRef: FirImplicitTypeRef,
                data: Nothing?
-            ): CompositeTransformResult<FirTypeRef> =
+            ): 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> {
+    ): 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<FirStatement> {
+    override fun transformBlock(block: FirBlock, data: ExpectedArgumentType?): FirStatement {
        val initialType = block.resultType.coneTypeSafe<ConeKotlinType>()
        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> {
+    ): FirStatement {
        return transformSyntheticCall(whenExpression, data)
    }

    override fun transformTryExpression(
        tryExpression: FirTryExpression,
        data: ExpectedArgumentType?
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return transformSyntheticCall(tryExpression, data)
    }

    override fun transformCheckNotNullCall(
        checkNotNullCall: FirCheckNotNullCall,
        data: ExpectedArgumentType?
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return transformSyntheticCall(checkNotNullCall, data)
    }

    override fun transformElvisExpression(
        elvisExpression: FirElvisExpression,
        data: ExpectedArgumentType?
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return transformSyntheticCall(elvisExpression, data)
    }

    private inline fun <reified D> transformSyntheticCall(
        syntheticCall: D,
        data: ExpectedArgumentType?,
-    ): CompositeTransformResult<FirStatement> 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 <reified D> transformSyntheticCallChildren(
@@ -692,20 +691,20 @@ class FirCallCompletionResultsWriterTransformer(
    override fun <T> transformConstExpression(
        constExpression: FirConstExpression<T>,
        data: ExpectedArgumentType?,
-    ): CompositeTransformResult<FirStatement> {
-        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<FirStatement> {
-        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<Nothing?>() {
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        return element
    }

-    override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+    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<FirDeclaration> {
+    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> {
+    ): FirDeclaration {
        propertyAccessor.transformReturnTypeRef(this, data)
        propertyAccessor.transformValueParameters(this, data)
-        return propertyAccessor.compose()
+        return propertyAccessor
    }

    override fun transformValueParameter(
        valueParameter: FirValueParameter,
        data: Nothing?
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        valueParameter.transformReturnTypeRef(this, data)
-        return valueParameter.compose()
+        return valueParameter
    }

-    override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+    override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): FirTypeRef {
        return finalSubstitutor.substituteOrNull(typeRef.coneType)?.let {
            typeRef.resolvedTypeFromPrototype(it)
-        }?.compose() ?: typeRef.compose()
+        } ?: typeRef
    }
 }
@@ -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<Nothing?>(phase) {
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> 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<FirFile> {
+    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<FirImport> {
-        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<FirImport> {
-        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()
+        }
    }
 }

@@ -74,23 +74,23 @@ class FirSealedClassInheritorsProcessor(
    }

    class InheritorsTransformer(private val inheritorsMap: MutableMap<FirRegularClass, MutableList<ClassId>>) : FirTransformer<Nothing?>() {
-        override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-            return element.compose()
+        override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+            return element
        }

-        override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirDeclaration> {
-            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<FirStatement> {
+        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)
        }
    }

@@ -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<FirResolvedTypeRef> {
+    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> {
+    ): 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<FirResolvedTypeRef> {
+    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<FirTypeRef> {
-        return resolvedTypeRef.compose()
+    override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: FirScope): FirTypeRef {
+        return resolvedTypeRef
    }

-    override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: FirScope): CompositeTransformResult<FirTypeRef> {
-        return implicitTypeRef.compose()
+    override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: FirScope): FirTypeRef {
+        return implicitTypeRef
    }
 }
@@ -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 : FirClassLikeDeclaration<F>> F.runStatusResolveForLocalClass(
        FirCompositeScope(scopesForLocalClass)
    )

-    return this.transform<F, Nothing?>(transformer, null).single
+    return this.transform<F, Nothing?>(transformer, null)
 }

 abstract class ResolvedStatusCalculator {
@@ -96,7 +94,7 @@ class FirStatusResolveTransformer(
    override fun transformRegularClass(
        regularClass: FirRegularClass,
        data: FirResolvedDeclarationStatus?
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        val computationStatus = statusComputationSession.startComputing(regularClass)
        forceResolveStatusesOfSupertypes(regularClass)
        /*
@@ -155,8 +153,8 @@ private class FirDesignatedStatusResolveTransformer(
    override fun transformRegularClass(
        regularClass: FirRegularClass,
        data: FirResolvedDeclarationStatus?
-    ): CompositeTransformResult<FirStatement> {
-        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<FirFile> {
+    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<FirDeclarationStatus> {
-        return (data ?: declarationStatus).compose()
+    ): FirDeclarationStatus {
+        return (data ?: declarationStatus)
    }

    private inline fun storeClass(
        klass: FirClass<*>,
-        computeResult: () -> CompositeTransformResult<FirDeclaration>
-    ): CompositeTransformResult<FirDeclaration> {
+        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> {
+    ): 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> {
+    ): 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>
+    ): FirStatement

    override fun transformAnonymousObject(
        anonymousObject: FirAnonymousObject,
        data: FirResolvedDeclarationStatus?
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        @Suppress("UNCHECKED_CAST")
        return transformClass(anonymousObject, data)
    }
@@ -339,7 +337,7 @@ abstract class AbstractFirStatusResolveTransformer(
    override fun <F : FirClass<F>> transformClass(
        klass: FirClass<F>,
        data: FirResolvedDeclarationStatus?
-    ): CompositeTransformResult<FirStatement> {
+    ): 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<FirStatement>
+            klass
+        } as FirStatement
    }

    protected fun updateResolvePhaseOfMembers(regularClass: FirRegularClass) {
@@ -447,7 +445,7 @@ abstract class AbstractFirStatusResolveTransformer(
    override fun transformConstructor(
        constructor: FirConstructor,
        data: FirResolvedDeclarationStatus?
-    ): CompositeTransformResult<FirDeclaration> {
+    ): 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> {
+    ): 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> {
+    ): 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> {
+    ): 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> {
+    ): 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> {
+    ): FirStatement {
        @Suppress("UNCHECKED_CAST")
-        return transformDeclaration(valueParameter, data) as CompositeTransformResult<FirStatement>
+        return transformDeclaration(valueParameter, data) as FirStatement
    }

    override fun transformTypeParameter(
        typeParameter: FirTypeParameter,
        data: FirResolvedDeclarationStatus?
-    ): CompositeTransformResult<FirDeclaration> {
+    ): FirDeclaration {
        return transformDeclaration(typeParameter, data)
    }

-    override fun transformBlock(block: FirBlock, data: FirResolvedDeclarationStatus?): CompositeTransformResult<FirStatement> {
-        return block.compose()
+    override fun transformBlock(block: FirBlock, data: FirResolvedDeclarationStatus?): FirStatement {
+        return block
    }
 }
@@ -46,11 +46,11 @@ class FirSupertypeResolverTransformer(
    private val supertypeResolverVisitor = FirSupertypeResolverVisitor(session, supertypeComputationSession, scopeSession)
    private val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession)

-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        return element
    }

-    override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
+    override fun transformFile(file: FirFile, data: Nothing?): FirFile {
        checkSessionConsistency(file)
        file.accept(supertypeResolverVisitor)
        supertypeComputationSession.breakLoops(session)
@@ -75,26 +75,26 @@ fun <F : FirClassLikeDeclaration<F>> F.runSupertypeResolvePhaseForLocalClass(
    supertypeComputationSession.breakLoops(session)

    val applySupertypesTransformer = FirApplySupertypesTransformer(supertypeComputationSession)
-    return this.transform<F, Nothing?>(applySupertypesTransformer, null).single
+    return this.transform<F, Nothing?>(applySupertypesTransformer, null)
 }

 private class FirApplySupertypesTransformer(
    private val supertypeComputationSession: SupertypeComputationSession
 ) : FirDefaultTransformer<Nothing?>() {
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        return element
    }

-    override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+    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<FirStatement> {
+    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<FirStatement> {
+    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<FirDeclaration> {
-        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<ConeTypeParameterType>()
                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,
@@ -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<FirNamedReferenceWithCandidate>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirNamedReferenceWithCandidate): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: FirNamedReferenceWithCandidate): E {
+        return element
    }

-    override fun transformReference(reference: FirReference, data: FirNamedReferenceWithCandidate): CompositeTransformResult<FirReference> {
-        return data.compose()
+    override fun transformReference(reference: FirReference, data: FirNamedReferenceWithCandidate): FirReference {
+        return data
    }
 }
@@ -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 : FirClassLikeDeclaration<F>> F.runTypeResolvePhaseForLocalClass(
 ): F {
    val transformer = FirTypeResolveTransformer(session, scopeSession, currentScopeList)

-    return this.transform<F, Nothing?>(transformer, null).single
+    return this.transform<F, Nothing?>(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<FirFile> {
+    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<FirStatement> {
+    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<FirStatement> {
+    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?): FirStatement {
        return resolveNestedClassesSupertypes(anonymousObject, data)
    }

-    override fun transformConstructor(constructor: FirConstructor, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+    override fun transformConstructor(constructor: FirConstructor, data: Nothing?): FirDeclaration {
        return withScopeCleanup {
            constructor.addTypeParametersScope()
            transformDeclaration(constructor, data)
        }
    }

-    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): FirDeclaration {
        return withScopeCleanup {
            typeAlias.addTypeParametersScope()
            transformDeclaration(typeAlias, data)
        }
    }

-    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): FirDeclaration {
        enumEntry.replaceResolvePhase(FirResolvePhase.TYPES)
        enumEntry.transformReturnTypeRef(this, data)
        enumEntry.transformTypeParameters(this, data)
        enumEntry.transformAnnotations(this, data)
-        return enumEntry.compose()
+        return enumEntry
    }

-    override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+    override fun transformProperty(property: FirProperty, data: Nothing?): FirDeclaration {
        return withScopeCleanup {
            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<FirDeclaration> {
+    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<FirDeclaration> {
+    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<FirTypeRef> {
+    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<FirResolvedTypeRef> {
+    override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): FirResolvedTypeRef {
        return typeResolverTransformer.withFile(currentFile) { typeRef.transform(typeResolverTransformer, towerScope) }
    }

-    override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult<FirStatement> {
+    override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): FirStatement {
        valueParameter.transformReturnTypeRef(this, data)
        valueParameter.transformAnnotations(this, data)
        valueParameter.transformVarargTypeToArrayType()
-        return valueParameter.compose()
+        return valueParameter
    }

-    override fun transformBlock(block: FirBlock, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return block.compose()
+    override fun transformBlock(block: FirBlock, data: Nothing?): FirStatement {
+        return block
    }

    override fun transformDelegatedConstructorCall(
        delegatedConstructorCall: FirDelegatedConstructorCall,
        data: Nothing?
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        delegatedConstructorCall.replaceConstructedTypeRef(
-            delegatedConstructorCall.constructedTypeRef.transform<FirTypeRef, Nothing?>(this, data).single
+            delegatedConstructorCall.constructedTypeRef.transform<FirTypeRef, Nothing?>(this, data)
        )
        delegatedConstructorCall.transformCalleeReference(this, data)
-        return delegatedConstructorCall.compose()
+        return delegatedConstructorCall
    }

-    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?): CompositeTransformResult<FirStatement> {
+    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?): FirStatement {
        annotationCall.transformAnnotationTypeRef(this, data)
-        return annotationCall.compose()
+        return annotationCall
    }
 }
@@ -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<Nothing?>() {
    companion object {
@@ -37,13 +35,13 @@ class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyRe
        )
    }

-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
        throw IllegalArgumentException("Should not be there")
    }

-    override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Nothing?): CompositeTransformResult<FirStatement> {
+    override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Nothing?): FirStatement {
        processExhaustivenessCheck(whenExpression)
-        return whenExpression.compose()
+        return whenExpression
    }

    @OptIn(ExperimentalStdlibApi::class)
@@ -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<ConeKotlinType?>() {
-    override fun <E : FirElement> transformElement(element: E, data: ConeKotlinType?): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: ConeKotlinType?): E {
+        return element
    }

    override fun <T> transformConstExpression(
        constExpression: FirConstExpression<T>,
        data: ConeKotlinType?
-    ): CompositeTransformResult<FirStatement> {
-        val type = constExpression.resultType.coneTypeSafe<ConeIntegerLiteralType>() ?: return constExpression.compose()
+    ): FirStatement {
+        val type = constExpression.resultType.coneTypeSafe<ConeIntegerLiteralType>() ?: return constExpression
        val approximatedType = type.getApproximatedType(data)
        constExpression.resultType = constExpression.resultType.resolvedTypeFromPrototype(approximatedType)
        @Suppress("UNCHECKED_CAST")
        val kind = approximatedType.toConstKind() as ConstantValueKind<T>
        constExpression.replaceKind(kind)
-        return constExpression.compose()
+        return constExpression
    }
 }
@@ -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<Nothing?>() {
    private object ArgumentsTransformer : FirTransformer<Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>>() {
-        override fun <E : FirElement> transformElement(element: E, data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>): CompositeTransformResult<E> {
-            return element.compose()
+        override fun <E : FirElement> transformElement(element: E, data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>): E {
+            return element
        }

        override fun transformAnonymousFunction(
            anonymousFunction: FirAnonymousFunction,
            data: Pair<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>
-        ): CompositeTransformResult<FirStatement> {
+        ): 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<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>
-        ): CompositeTransformResult<FirStatement> {
+        ): 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<Map<FirExpression, EventOccurrencesRange>, EventOccurrencesRange?>
-        ): CompositeTransformResult<FirStatement> {
+        ): 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 <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        return element
    }

-    override fun transformFunctionCall(functionCall: FirFunctionCall, data: Nothing?): CompositeTransformResult<FirStatement> {
-        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<Nothing?>() {

        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<Nothing?>() {
            }
        }
        if (invocationKindMapping.isEmpty()) {
-            return functionCall.compose()
+            return functionCall
        }
        functionCall.argumentList.transformArguments(ArgumentsTransformer, invocationKindMapping to null)
-        return functionCall.compose()
+        return functionCall
    }
 }
@@ -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<Nothing?>() {
-        override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-            return element.compose()
+        override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+            return element
        }
    }
 }
@@ -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<FirTypeRef>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): E {
+        return element
    }

-    override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): CompositeTransformResult<FirTypeRef> {
-        return data.compose()
+    override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): FirTypeRef {
+        return data
    }
 }

 internal object TransformImplicitType : FirDefaultTransformer<FirTypeRef>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): E {
+        return element
    }

    override fun transformImplicitTypeRef(
        implicitTypeRef: FirImplicitTypeRef,
        data: FirTypeRef
-    ): CompositeTransformResult<FirTypeRef> {
-        return data.compose()
+    ): FirTypeRef {
+        return data
    }
 }


 internal object StoreNameReference : FirDefaultTransformer<FirNamedReference>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): E {
+        return element
    }

    override fun transformNamedReference(
        namedReference: FirNamedReference,
        data: FirNamedReference
-    ): CompositeTransformResult<FirNamedReference> {
-        return data.compose()
+    ): FirNamedReference {
+        return data
    }

-    override fun transformThisReference(thisReference: FirThisReference, data: FirNamedReference): CompositeTransformResult<FirReference> {
-        return data.compose()
+    override fun transformThisReference(thisReference: FirThisReference, data: FirNamedReference): FirReference {
+        return data
    }

    override fun transformSuperReference(
        superReference: FirSuperReference,
        data: FirNamedReference
-    ): CompositeTransformResult<FirReference> {
-        return data.compose()
+    ): FirReference {
+        return data
    }
 }

 internal object StoreCalleeReference : FirTransformer<FirNamedReference>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): E {
+        return element
    }

    override fun transformNamedReference(
        namedReference: FirNamedReference,
        data: FirNamedReference
-    ): CompositeTransformResult<FirNamedReference> {
-        return data.compose()
+    ): FirNamedReference {
+        return data
    }

    override fun transformResolvedNamedReference(
        resolvedNamedReference: FirResolvedNamedReference,
        data: FirNamedReference
-    ): CompositeTransformResult<FirNamedReference> {
-        return data.compose()
+    ): FirNamedReference {
+        return data
    }
 }

 internal object StoreReceiver : FirTransformer<FirExpression>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirExpression): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: FirExpression): E {
        @Suppress("UNCHECKED_CAST")
-        return (data as E).compose()
+        return (data as E)
    }
 }

@@ -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<FirFile> {
+    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<FirFile>
+            transformDeclarationContent(file, data) as FirFile
        }
    }

-    override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): E {
        @Suppress("UNCHECKED_CAST")
-        return (element.transformChildren(this, data) as E).compose()
+        return (element.transformChildren(this, data) as E)
    }

-    override fun transformTypeRef(typeRef: FirTypeRef, data: ResolutionMode): CompositeTransformResult<FirResolvedTypeRef> {
+    override fun transformTypeRef(typeRef: FirTypeRef, data: ResolutionMode): FirResolvedTypeRef {
        if (typeRef is FirResolvedTypeRef) {
-            return typeRef.compose()
+            return typeRef
        }
        return typeResolverTransformer.withFile(context.file) {
            transformTypeRef(typeRef, FirCompositeScope(components.createCurrentScopeList()))
        }
    }

-    override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: ResolutionMode): CompositeTransformResult<FirTypeRef> {
+    override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: ResolutionMode): FirTypeRef {
        if (data !is ResolutionMode.WithExpectedType)
-            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<FirStatement> {
+    override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement {
        return expressionsTransformer.transformExpression(expression, data)
    }

    override fun transformWrappedArgumentExpression(
        wrappedArgumentExpression: FirWrappedArgumentExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return transformElement(wrappedArgumentExpression, data)
    }

    override fun transformQualifiedAccessExpression(
        qualifiedAccessExpression: FirQualifiedAccessExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformQualifiedAccessExpression(qualifiedAccessExpression, data)
    }

-    override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): FirStatement {
        return expressionsTransformer.transformFunctionCall(functionCall, data)
    }

    override fun transformCallableReferenceAccess(
        callableReferenceAccess: FirCallableReferenceAccess,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformCallableReferenceAccess(callableReferenceAccess, data)
    }

-    override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformBlock(block: FirBlock, data: ResolutionMode): FirStatement {
        return expressionsTransformer.transformBlock(block, data)
    }

    override fun transformThisReceiverExpression(
        thisReceiverExpression: FirThisReceiverExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformThisReceiverExpression(thisReceiverExpression, data)
    }

    override fun transformComparisonExpression(
        comparisonExpression: FirComparisonExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformComparisonExpression(comparisonExpression, data)
    }

    override fun transformTypeOperatorCall(
        typeOperatorCall: FirTypeOperatorCall,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformTypeOperatorCall(typeOperatorCall, data)
    }

    override fun transformAssignmentOperatorStatement(
        assignmentOperatorStatement: FirAssignmentOperatorStatement,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformAssignmentOperatorStatement(assignmentOperatorStatement, data)
    }

    override fun transformEqualityOperatorCall(
        equalityOperatorCall: FirEqualityOperatorCall,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformEqualityOperatorCall(equalityOperatorCall, data)
    }

    override fun transformCheckNotNullCall(
        checkNotNullCall: FirCheckNotNullCall,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformCheckNotNullCall(checkNotNullCall, data)
    }

    override fun transformBinaryLogicExpression(
        binaryLogicExpression: FirBinaryLogicExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformBinaryLogicExpression(binaryLogicExpression, data)
    }

    override fun transformVariableAssignment(
        variableAssignment: FirVariableAssignment,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformVariableAssignment(variableAssignment, data)
    }

-    override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformGetClassCall(getClassCall: FirGetClassCall, data: ResolutionMode): FirStatement {
        return expressionsTransformer.transformGetClassCall(getClassCall, data)
    }

    override fun transformWrappedDelegateExpression(
        wrappedDelegateExpression: FirWrappedDelegateExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return declarationsTransformer.transformWrappedDelegateExpression(wrappedDelegateExpression, data)
    }

    override fun <T> transformConstExpression(
        constExpression: FirConstExpression<T>,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformConstExpression(constExpression, data)
    }

-    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement {
        return expressionsTransformer.transformAnnotationCall(annotationCall, data)
    }

    override fun transformDelegatedConstructorCall(
        delegatedConstructorCall: FirDelegatedConstructorCall,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformDelegatedConstructorCall(delegatedConstructorCall, data)
    }

    override fun transformAugmentedArraySetCall(
        augmentedArraySetCall: FirAugmentedArraySetCall,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformAugmentedArraySetCall(augmentedArraySetCall, data)
    }

    override fun transformSafeCallExpression(
        safeCallExpression: FirSafeCallExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformSafeCallExpression(safeCallExpression, data)
    }

    override fun transformCheckedSafeCallSubject(
        checkedSafeCallSubject: FirCheckedSafeCallSubject,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return expressionsTransformer.transformCheckedSafeCallSubject(checkedSafeCallSubject, data)
    }

    // ------------------------------------- Declarations -------------------------------------

-    override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
+    override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration {
        return declarationsTransformer.transformDeclaration(declaration, data)
    }

    open fun transformDeclarationContent(
        declaration: FirDeclaration, data: ResolutionMode
-    ): CompositeTransformResult<FirDeclaration> {
+    ): FirDeclaration {
        return transformElement(declaration, data)
    }

    override fun transformDeclarationStatus(
        declarationStatus: FirDeclarationStatus,
        data: ResolutionMode
-    ): CompositeTransformResult<FirDeclarationStatus> {
+    ): FirDeclarationStatus {
        return declarationsTransformer.transformDeclarationStatus(declarationStatus, data)
    }

-    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
+    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirDeclaration {
        return declarationsTransformer.transformEnumEntry(enumEntry, data)
    }

-    override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirProperty> {
+    override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
        return declarationsTransformer.transformProperty(property, data)
    }

-    override fun transformField(field: FirField, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
+    override fun transformField(field: FirField, data: ResolutionMode): FirDeclaration {
        return declarationsTransformer.transformField(field, data)
    }

-    override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement {
        return declarationsTransformer.transformRegularClass(regularClass, data)
    }

    override fun transformAnonymousObject(
        anonymousObject: FirAnonymousObject,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return declarationsTransformer.transformAnonymousObject(anonymousObject, data)
    }

    override fun transformSimpleFunction(
        simpleFunction: FirSimpleFunction,
        data: ResolutionMode
-    ): CompositeTransformResult<FirSimpleFunction> {
+    ): FirSimpleFunction {
        return declarationsTransformer.transformSimpleFunction(simpleFunction, data)
    }

    override fun <F : FirFunction<F>> transformFunction(
        function: FirFunction<F>,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return declarationsTransformer.transformFunction(function, data)
    }

-    override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
+    override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration {
        return declarationsTransformer.transformConstructor(constructor, data)
    }

    override fun transformAnonymousInitializer(
        anonymousInitializer: FirAnonymousInitializer,
        data: ResolutionMode
-    ): CompositeTransformResult<FirDeclaration> {
+    ): FirDeclaration {
        return declarationsTransformer.transformAnonymousInitializer(anonymousInitializer, data)
    }

    override fun transformAnonymousFunction(
        anonymousFunction: FirAnonymousFunction,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return declarationsTransformer.transformAnonymousFunction(anonymousFunction, data)
    }

-    override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement {
        return declarationsTransformer.transformValueParameter(valueParameter, data)
    }

-    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
+    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirDeclaration {
        return declarationsTransformer.transformTypeAlias(typeAlias, data)
    }

    // ------------------------------------- Control flow statements -------------------------------------

-    override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): FirStatement {
        return controlFlowStatementsTransformer.transformWhileLoop(whileLoop, data)
    }

-    override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: ResolutionMode): FirStatement {
        return controlFlowStatementsTransformer.transformDoWhileLoop(doWhileLoop, data)
    }

-    override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformWhenExpression(whenExpression: FirWhenExpression, data: ResolutionMode): FirStatement {
        return controlFlowStatementsTransformer.transformWhenExpression(whenExpression, data)
    }

-    override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): CompositeTransformResult<FirWhenBranch> {
+    override fun transformWhenBranch(whenBranch: FirWhenBranch, data: ResolutionMode): FirWhenBranch {
        return controlFlowStatementsTransformer.transformWhenBranch(whenBranch, data)
    }

    override fun transformWhenSubjectExpression(
        whenSubjectExpression: FirWhenSubjectExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return controlFlowStatementsTransformer.transformWhenSubjectExpression(whenSubjectExpression, data)
    }

-    override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformTryExpression(tryExpression: FirTryExpression, data: ResolutionMode): FirStatement {
        return controlFlowStatementsTransformer.transformTryExpression(tryExpression, data)
    }

-    override fun transformCatch(catch: FirCatch, data: ResolutionMode): CompositeTransformResult<FirCatch> {
+    override fun transformCatch(catch: FirCatch, data: ResolutionMode): FirCatch {
        return controlFlowStatementsTransformer.transformCatch(catch, data)
    }

-    override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: ResolutionMode): FirStatement {
        return controlFlowStatementsTransformer.transformJump(jump, data)
    }

    override fun transformReturnExpression(
        returnExpression: FirReturnExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return controlFlowStatementsTransformer.transformReturnExpression(returnExpression, data)
    }

    override fun transformThrowExpression(
        throwExpression: FirThrowExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return controlFlowStatementsTransformer.transformThrowExpression(throwExpression, data)
    }

    override fun transformElvisExpression(
        elvisExpression: FirElvisExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return controlFlowStatementsTransformer.transformElvisExpression(elvisExpression, data)
    }

@@ -368,6 +366,6 @@ open class FirBodyResolveTransformer(

    fun <D> FirElement.visitNoTransform(transformer: FirTransformer<D>, data: D) {
        val result = this.transform<FirElement, D>(transformer, data)
-        require(result.single === this) { "become ${result.single}: `${result.single.render()}`, was ${this}: `${this.render()}`" }
+        require(result === this) { "become $result: `${result.render()}`, was ${this}: `${this.render()}`" }
    }
 }
@@ -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 <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        return element
    }

-    override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
+    override fun transformFile(file: FirFile, data: Nothing?): FirFile {
        return file.transform(transformer, ResolutionMode.ContextIndependent)
    }
 }
@@ -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<FirStatement> {
+    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<FirStatement> {
+    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<FirStatement> {
+    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<FirWhenBranch> {
+    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> {
+    ): 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<FirStatement> {
+    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<FirCatch> {
+    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 <E : FirTargetElement> transformJump(jump: FirJump<E>, data: ResolutionMode): CompositeTransformResult<FirStatement> {
-        val result = transformer.transformExpression(jump, data).single
+    override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, 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> {
+    ): 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> {
+    ): 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<FirStatement> {
-        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<ConeKotlinType>()
@@ -242,6 +240,6 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
        }

        dataFlowAnalyzer.exitElvis(elvisExpression)
-        return result.compose()
+        return result
    }
 }
@@ -63,7 +63,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor

    private fun transformDeclarationContent(
        declaration: FirDeclaration, data: ResolutionMode
-    ): CompositeTransformResult<FirDeclaration> {
+    ): 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<FirDeclarationStatus> {
-        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<FirDeclaration> {
-        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<FirProperty> {
+    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<FirDeclaration> {
+    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> {
+    ): 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<FirProperty> {
+    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<FirStatement> {
+    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<FirDeclaration> {
+    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> {
+    ): 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> {
+    ): 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> {
+    ): 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 <F : FirFunction<F>> transformFunctionWithGivenSignature(
        function: F,
        resolutionMode: ResolutionMode,
-    ): CompositeTransformResult<F> {
+    ): 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 <F : FirFunction<F>> transformFunction(
        function: FirFunction<F>,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): 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<FirStatement>
+        } as FirStatement
    }

-    override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
-        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<FirConstructor> {
+    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<FirDeclaration> {
-        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<FirStatement> {
+    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> {
+    ): 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<FirExpression>() {
-                    override fun <E : FirElement> transformElement(element: E, data: FirExpression): CompositeTransformResult<E> {
+                    override fun <E : FirElement> transformElement(element: E, data: FirExpression): E {
                        if (element == lastStatement) {
                            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<FirStatement> {
-                        return returnExpression.compose()
+                    ): FirStatement {
+                        return returnExpression
                    }
                },
                buildUnitExpression()
@@ -844,11 +843,11 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
    }

    private object ImplicitToErrorTypeTransformer : FirTransformer<Nothing?>() {
-        override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-            return element.compose()
+        override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+            return element
        }

-        override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult<FirStatement> {
+        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
        }
    }
 }
@@ -49,7 +49,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
        components.callResolver.initTransformer(this)
    }

-    override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement {
        if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) {
            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> {
+    ): 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> {
+    ): 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<FirStatement> {
-        return checkedSafeCallSubject.compose()
+    ): FirStatement {
+        return checkedSafeCallSubject
    }

-    override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): FirStatement {
        if (functionCall.calleeReference is FirResolvedNamedReference && functionCall.resultType is FirImplicitTypeRef) {
            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<FirStatement> {
+    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> {
+    ): FirStatement {
        return transformQualifiedAccessExpression(thisReceiverExpression, data)
    }

    override fun transformComparisonExpression(
        comparisonExpression: FirComparisonExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
+    ): 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> {
+    ): 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> {
+    ): 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 <T> resolveCandidateForAssignmentOperatorCall(block: () -> T): T {
@@ -540,22 +540,22 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
    override fun transformTypeOperatorCall(
        typeOperatorCall: FirTypeOperatorCall,
        data: ResolutionMode,
-    ): CompositeTransformResult<FirStatement> {
+    ): 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<Nothing?>() {
-            override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-                return element.compose()
+            override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+                return element
            }

-            override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+            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> {
+    ): FirStatement {
        // Resolve the return type of a call to the synthetic function with signature:
        //   fun <K> 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> {
+    ): 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> {
+    ): 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> {
+    ): 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<FirStatement> {
+    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 <T> transformConstExpression(
        constExpression: FirConstExpression<T>,
        data: ResolutionMode,
-    ): CompositeTransformResult<FirStatement> {
+    ): 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<FirStatement> {
-        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> {
+    ): 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<FirStatement> {
-        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<ConeClassLikeType>()
-                        ?.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> {
+    ): 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
    }

    // ------------------------------------------------------------------------------------------------
@@ -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 <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        return element
    }

-    override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
+    override fun transformFile(file: FirFile, data: Nothing?): FirFile {
        return file.transform(transformer, ResolutionMode.ContextIndependent)
    }
 }
@@ -94,7 +92,7 @@ fun <F : FirClassLikeDeclaration<F>> F.runContractAndBodiesResolutionForLocalCla
    val members = localClassesNavigationInfo.allMembers
    graphBuilder.prepareForLocalClassMembers(members)

-    return this.transform<F, ResolutionMode>(transformer, resolutionMode).single.also {
+    return this.transform<F, ResolutionMode>(transformer, resolutionMode).also {
        graphBuilder.cleanAfterForLocalClassMembers(members)
    }
 }
@@ -138,13 +136,13 @@ open class FirImplicitAwareBodyResolveTransformer(
    override fun transformSimpleFunction(
        simpleFunction: FirSimpleFunction,
        data: ResolutionMode
-    ): CompositeTransformResult<FirSimpleFunction> {
+    ): FirSimpleFunction {
        return computeCachedTransformationResult(simpleFunction) {
            super.transformSimpleFunction(simpleFunction, data)
        }
    }

-    override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirProperty> {
+    override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
        return computeCachedTransformationResult(property) {
            super.transformProperty(property, data)
        }
@@ -152,18 +150,18 @@ open class FirImplicitAwareBodyResolveTransformer(

    private fun <D : FirCallableMemberDeclaration<D>> computeCachedTransformationResult(
        member: D,
-        transform: () -> CompositeTransformResult<D>
-    ): CompositeTransformResult<D> {
+        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<D>
+            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<FirDeclaration> {
+    override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration {
        if (designation.hasNext()) {
-            val result = designation.next().transform<FirDeclaration, ResolutionMode>(this, data).single
+            val result = designation.next().transform<FirDeclaration, ResolutionMode>(this, data)
            if (!designation.hasNext() && lastResult == null) {
                lastResult = result
            }
-            return declaration.compose()
+            return declaration
        }

        return super.transformDeclarationContent(declaration, data)
@@ -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 <E : FirElement> transformElement(element: E, data: ResolutionMode): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): E {
        return element.transform(transformer, data)
    }
 }
@@ -43,18 +43,18 @@ open class FirContractResolveTransformer(
 ) {
    override val declarationsTransformer: FirDeclarationsResolveTransformer = FirDeclarationsContractResolveTransformer(this)

-    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
-        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> {
+        ): 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<FirProperty> {
+        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<FirDeclaration> {
+        override fun transformField(field: FirField, data: ResolutionMode): FirDeclaration {
            field.updatePhase()
-            return field.compose()
+            return field
        }

        private fun transformPropertyAccessor(
            propertyAccessor: FirPropertyAccessor,
            owner: FirProperty
-        ): CompositeTransformResult<FirStatement> {
+        ): 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 <T : FirContractDescriptionOwner> transformContractDescriptionOwner(
            owner: T
-        ): CompositeTransformResult<T> {
+        ): T {
            dataFlowAnalyzer.enterContractDescription()
            return when (val contractDescription = owner.contractDescription) {
                is FirLegacyRawContractDescription -> transformLegacyRawContractDescriptionOwner(owner, contractDescription)
@@ -124,7 +124,7 @@ open class FirContractResolveTransformer(
        private fun <T : FirContractDescriptionOwner> transformLegacyRawContractDescriptionOwner(
            owner: T,
            contractDescription: FirLegacyRawContractDescription
-        ): CompositeTransformResult<T> {
+        ): 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 <T : FirContractDescriptionOwner> transformRawContractDescriptionOwner(
            owner: T,
            contractDescription: FirRawContractDescription
-        ): CompositeTransformResult<T> {
+        ): T {
            val effectsBlock = buildAnonymousFunction {
                session = this@FirDeclarationsContractResolveTransformer.session
                origin = FirDeclarationOrigin.Source
@@ -194,64 +194,64 @@ open class FirContractResolveTransformer(
            return transformLegacyRawContractDescriptionOwner(owner, legacyRawContractDescription)
        }

-        private fun <T : FirContractDescriptionOwner> transformOwnerWithUnresolvedContract(owner: T): CompositeTransformResult<T> {
+        private fun <T : FirContractDescriptionOwner> transformOwnerWithUnresolvedContract(owner: T): T {
            return when (val contractDescription = owner.contractDescription) {
                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<FirStatement> {
+        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> {
+        ): FirStatement {
            anonymousObject.updatePhase()
            context.withAnonymousObject(anonymousObject, components) {
                anonymousObject.transformDeclarations(this, data)
            }
-            return anonymousObject.compose()
+            return anonymousObject
        }

        override fun transformAnonymousInitializer(
            anonymousInitializer: FirAnonymousInitializer,
            data: ResolutionMode
-        ): CompositeTransformResult<FirDeclaration> {
-            return anonymousInitializer.compose()
+        ): FirDeclaration {
+            return anonymousInitializer
        }

-        override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
+        override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration {
            constructor.updatePhase()
-            return constructor.compose()
+            return constructor
        }

-        override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
-            return enumEntry.compose()
+        override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirDeclaration {
+            return enumEntry
        }

-        private fun <T : FirContractDescriptionOwner> transformOwnerOfErrorContract(owner: T): CompositeTransformResult<T> {
+        private fun <T : FirContractDescriptionOwner> transformOwnerOfErrorContract(owner: T): T {
            // TODO
            dataFlowAnalyzer.exitContractDescription()
-            return owner.compose()
+            return owner
        }

        private val FirContractDescriptionOwner.hasContractToResolve: Boolean
@@ -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<Nothing?>() {
    private val transformer = FirContractResolveTransformer(session, scopeSession)
-    override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        return element
    }

-    override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+    override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
        return file.transform(transformer, ResolutionMode.ContextIndependent)
    }
 }
@@ -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<D, S>(
    protected val session: FirSession,
    protected val scopeSession: ScopeSession
 ) : FirDefaultTransformer<D>() {
-    abstract override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult<FirStatement>
+    abstract override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement

    protected lateinit var scope: FirScope

-    override fun transformFile(file: FirFile, data: D): CompositeTransformResult<FirDeclaration> {
+    override fun transformFile(file: FirFile, data: D): FirDeclaration {
        scope = FirCompositeScope(createImportingScopes(file, session, scopeSession, useCaching = false))
        val state = beforeChildren(file)
        file.transformDeclarations(this, data)
@@ -36,14 +34,14 @@ internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
        return transformAnnotatedDeclaration(file, data)
    }

-    override fun transformProperty(property: FirProperty, data: D): CompositeTransformResult<FirDeclaration> {
+    override fun transformProperty(property: FirProperty, data: D): FirDeclaration {
        return transformAnnotatedDeclaration(property, data)
    }

    override fun transformRegularClass(
        regularClass: FirRegularClass,
        data: D
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        @Suppress("UNCHECKED_CAST")
        return transformAnnotatedDeclaration(regularClass, data).also {
            val state = beforeChildren(regularClass)
@@ -51,13 +49,13 @@ internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
            regularClass.transformCompanionObject(this, data)
            regularClass.transformSuperTypeRefs(this, data)
            afterChildren(state)
-        } as CompositeTransformResult<FirStatement>
+        } as FirStatement
    }

    override fun transformSimpleFunction(
        simpleFunction: FirSimpleFunction,
        data: D
-    ): CompositeTransformResult<FirDeclaration> {
+    ): FirDeclaration {
        return transformAnnotatedDeclaration(simpleFunction, data).also {
            val state = beforeChildren(simpleFunction)
            simpleFunction.transformValueParameters(this, data)
@@ -68,7 +66,7 @@ internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
    override fun transformConstructor(
        constructor: FirConstructor,
        data: D
-    ): CompositeTransformResult<FirDeclaration> {
+    ): FirDeclaration {
        return transformAnnotatedDeclaration(constructor, data).also {
            val state = beforeChildren(constructor)
            constructor.transformValueParameters(this, data)
@@ -79,37 +77,37 @@ internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
    override fun transformValueParameter(
        valueParameter: FirValueParameter,
        data: D
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        @Suppress("UNCHECKED_CAST")
-        return transformAnnotatedDeclaration(valueParameter, data) as CompositeTransformResult<FirStatement>
+        return transformAnnotatedDeclaration(valueParameter, data) as FirStatement
    }

-    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult<FirDeclaration> {
+    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): FirDeclaration {
        return transformAnnotatedDeclaration(typeAlias, data)
    }

-    override fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+    override fun transformTypeRef(typeRef: FirTypeRef, data: D): FirTypeRef {
        @Suppress("UNCHECKED_CAST")
-        return transformAnnotationContainer(typeRef, data) as CompositeTransformResult<FirTypeRef>
+        return transformAnnotationContainer(typeRef, data) as FirTypeRef
    }

    override fun transformAnnotatedDeclaration(
        annotatedDeclaration: FirAnnotatedDeclaration,
        data: D
-    ): CompositeTransformResult<FirDeclaration> {
+    ): FirDeclaration {
        @Suppress("UNCHECKED_CAST")
-        return transformAnnotationContainer(annotatedDeclaration, data) as CompositeTransformResult<FirDeclaration>
+        return transformAnnotationContainer(annotatedDeclaration, data) as FirDeclaration
    }

    override fun transformAnnotationContainer(
        annotationContainer: FirAnnotationContainer,
        data: D
-    ): CompositeTransformResult<FirAnnotationContainer> {
-        return annotationContainer.transformAnnotations(this, data).compose()
+    ): FirAnnotationContainer {
+        return annotationContainer.transformAnnotations(this, data)
    }

-    override fun <E : FirElement> transformElement(element: E, data: D): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: D): E {
+        return element
    }

    protected open fun beforeChildren(declaration: FirAnnotatedDeclaration): S? {
@@ -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 <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+        return element
    }

-    override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirDeclaration> {
-        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)
    }
 }
@@ -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<FirStatement> {
-        return wrappedDelegateExpression.compose()
+    ): FirStatement {
+        return wrappedDelegateExpression
    }

-    override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult<FirStatement> {
-        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<FirDeclaration> {
-        return anonymousInitializer.compose()
+    ): FirDeclaration {
+        return anonymousInitializer
    }

    override fun transformSimpleFunction(
        simpleFunction: FirSimpleFunction,
        data: ResolutionMode
-    ): CompositeTransformResult<FirSimpleFunction> {
-        return simpleFunction.transformAnnotations(this, data).compose()
+    ): FirSimpleFunction {
+        return simpleFunction.transformAnnotations(this, data)
    }

-    override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
-        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<FirStatement> {
-        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<FirProperty> {
+    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> {
+    ): 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<FirStatement> {
+    override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement {
        if (annotationArgumentsMode) {
            return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.PartiallyResolved)
        }

        annotationCall.transformAnnotationTypeRef(transformer, data)
        val classId = annotationCall.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.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<FirStatement> {
-        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<FirStatement> {
-        return functionCall.compose()
+    override fun transformFunctionCall(functionCall: FirFunctionCall, data: ResolutionMode): FirStatement {
+        return functionCall
    }

-    override fun transformBlock(block: FirBlock, data: ResolutionMode): CompositeTransformResult<FirStatement> {
-        return block.compose()
+    override fun transformBlock(block: FirBlock, data: ResolutionMode): FirStatement {
+        return block
    }

    override fun transformThisReceiverExpression(
        thisReceiverExpression: FirThisReceiverExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
-        return thisReceiverExpression.compose()
+    ): FirStatement {
+        return thisReceiverExpression
    }

    override fun transformComparisonExpression(
        comparisonExpression: FirComparisonExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
-        return comparisonExpression.compose()
+    ): FirStatement {
+        return comparisonExpression
    }

    override fun transformTypeOperatorCall(
        typeOperatorCall: FirTypeOperatorCall,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
-        return typeOperatorCall.compose()
+    ): FirStatement {
+        return typeOperatorCall
    }

    override fun transformCheckNotNullCall(
        checkNotNullCall: FirCheckNotNullCall,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
-        return checkNotNullCall.compose()
+    ): FirStatement {
+        return checkNotNullCall
    }

    override fun transformBinaryLogicExpression(
        binaryLogicExpression: FirBinaryLogicExpression,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
-        return binaryLogicExpression.compose()
+    ): FirStatement {
+        return binaryLogicExpression
    }

    override fun transformVariableAssignment(
        variableAssignment: FirVariableAssignment,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
-        return variableAssignment.compose()
+    ): FirStatement {
+        return variableAssignment
    }

    override fun transformCallableReferenceAccess(
        callableReferenceAccess: FirCallableReferenceAccess,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
-        return callableReferenceAccess.compose()
+    ): FirStatement {
+        return callableReferenceAccess
    }

    override fun transformDelegatedConstructorCall(
        delegatedConstructorCall: FirDelegatedConstructorCall,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
-        return delegatedConstructorCall.compose()
+    ): FirStatement {
+        return delegatedConstructorCall
    }

    override fun transformAugmentedArraySetCall(
        augmentedArraySetCall: FirAugmentedArraySetCall,
        data: ResolutionMode
-    ): CompositeTransformResult<FirStatement> {
-        return augmentedArraySetCall.compose()
+    ): FirStatement {
+        return augmentedArraySetCall
    }
 }
@@ -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 <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
-            return element.compose()
+        override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
+            return element
        }

-        override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): FirDeclaration {
            typeAlias.updateStatus()
-            return typeAlias.compose()
+            return typeAlias
        }

-        override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirStatement> {
+        override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement {
            regularClass.updateStatus()
            regularClass.transformDeclarations(this, data)
-            return regularClass.compose()
+            return regularClass
        }

-        override fun transformConstructor(constructor: FirConstructor, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        override fun transformConstructor(constructor: FirConstructor, data: Nothing?): FirDeclaration {
            constructor.updateStatus()
-            return constructor.compose()
+            return constructor
        }

-        override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        override fun transformProperty(property: FirProperty, data: Nothing?): FirDeclaration {
            property.updateStatus()
            property.transformGetter(this, data)
            property.transformSetter(this, data)
-            return property.compose()
+            return property
        }

-        override fun transformField(field: FirField, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        override fun transformField(field: FirField, data: Nothing?): FirDeclaration {
            field.updateStatus()
-            return field.compose()
+            return field
        }

-        override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): FirDeclaration {
            enumEntry.updateStatus()
-            return enumEntry.compose()
+            return enumEntry
        }

-        override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): FirDeclaration {
            simpleFunction.updateStatus()
-            return simpleFunction.compose()
+            return simpleFunction
        }
    }
 }

 private object ReplaceStatus : FirTransformer<FirDeclarationStatus>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirDeclarationStatus): CompositeTransformResult<E> {
-        return element.compose()
+    override fun <E : FirElement> transformElement(element: E, data: FirDeclarationStatus): E {
+        return element
    }

    override fun transformDeclarationStatus(
        declarationStatus: FirDeclarationStatus,
        data: FirDeclarationStatus
-    ): CompositeTransformResult<FirDeclarationStatus> {
-        return data.compose()
+    ): FirDeclarationStatus {
+        return data
    }
 }
@@ -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 <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: Nothing?): E {
        throw IllegalStateException("Should not be here")
    }

-    override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
+    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<AnnotationFqn, FirRegularClass>
-    ): CompositeTransformResult<FirStatement> {
-        return annotationCall.transformAnnotationTypeRef(typeResolverTransformer, scope).compose()
+    ): FirStatement {
+        return annotationCall.transformAnnotationTypeRef(typeResolverTransformer, scope)
    }

    override fun transformRegularClass(
        regularClass: FirRegularClass,
        data: Multimap<AnnotationFqn, FirRegularClass>
-    ): CompositeTransformResult<FirStatement> {
+    ): 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<AnnotationFqn, FirRegularClass>
-    ): CompositeTransformResult<FirDeclaration> {
+    ): FirDeclaration {
        return super.transformAnnotatedDeclaration(annotatedDeclaration, data).also {
            session.predicateBasedProvider.registerAnnotatedDeclaration(annotatedDeclaration, owners)
        }
@@ -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)
@@ -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 <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): CompositeTransformResult<E> =
-        accept(visitor, data) as CompositeTransformResult<E>
+    fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): E =
+        accept(visitor, data) as E

    fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement
 }
@@ -1,45 +0,0 @@
-/*
- * Copyright 2000-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.fir.visitors
-
-import org.jetbrains.kotlin.fir.FirElement
-
-sealed class CompositeTransformResult<out T : Any> {
-
-    class Single<out T : Any>(val _single: T) : CompositeTransformResult<T>()
-
-    class Multiple<out T : Any>(val _list: List<T>) : CompositeTransformResult<T>()
-
-    companion object {
-        fun <T : Any> empty() = Multiple(emptyList<T>())
-        fun <T : Any> single(t: T) = Single(t)
-        fun <T : Any> many(l: List<T>) = Multiple(l)
-    }
-
-    @Suppress("UNCHECKED_CAST")
-    val list: List<T>
-        get() = when (this) {
-            is Multiple<*> -> _list as List<T>
-            else -> error("!")
-        }
-
-
-    @Suppress("UNCHECKED_CAST")
-    val single: T
-        get() = when (this) {
-            is Single<*> -> _single as T
-            else -> error("!")
-        }
-
-    val isSingle
-        get() = this is Single<*>
-
-    val isEmpty
-        get() = this is Multiple<*> && this.list.isEmpty()
-}
-
-@Suppress("NOTHING_TO_INLINE")
-inline fun <T : FirElement> T.compose() = CompositeTransformResult.single(this)
@@ -12,94 +12,94 @@ import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.*

 abstract class FirDefaultTransformer<D> : FirTransformer<D>() {
-    override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+    override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): FirTypeRef {
        return transformTypeRef(implicitTypeRef, data)
    }

-    override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+    override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): FirTypeRef {
        return transformTypeRef(resolvedTypeRef, data)
    }

-    override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+    override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): FirTypeRef {
        return transformResolvedTypeRef(errorTypeRef, data)
    }

-    override fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult<FirTypeRef> {
+    override fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): FirTypeRef {
        return transformTypeRef(typeRefWithNullability, data)
    }

-    override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+    override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): FirTypeRef {
        return transformTypeRefWithNullability(dynamicTypeRef, data)
    }

-    override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+    override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): FirTypeRef {
        return transformTypeRefWithNullability(functionTypeRef, data)
    }

-    override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+    override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): FirTypeRef {
        return transformTypeRefWithNullability(userTypeRef, data)
    }

    override fun transformCallableReferenceAccess(
        callableReferenceAccess: FirCallableReferenceAccess,
        data: D
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return transformQualifiedAccessExpression(callableReferenceAccess, data)
    }

-    override fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult<FirStatement> {
+    override fun transformComponentCall(componentCall: FirComponentCall, data: D): FirStatement {
        return transformFunctionCall(componentCall, data)
    }

-    override fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult<FirStatement> {
+    override fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): FirStatement {
        return transformJump(returnExpression, data)
    }

-    override fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult<FirStatement> {
+    override fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): FirStatement {
        return transformJump(continueExpression, data)
    }

-    override fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult<FirStatement> {
+    override fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): FirStatement {
        return transformJump(breakExpression, data)
    }


-    override fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
+    override fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): FirStatement {
        return transformWrappedArgumentExpression(lambdaArgumentExpression, data)
    }

-    override fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
+    override fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): FirStatement {
        return transformWrappedArgumentExpression(spreadArgumentExpression, data)
    }

-    override fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
+    override fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): FirStatement {
        return transformWrappedArgumentExpression(namedArgumentExpression, data)
    }

-    override fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult<FirStatement> {
+    override fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): FirStatement {
        return transformExpression(errorExpression, data)
    }

-    override fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): CompositeTransformResult<FirStatement> {
+    override fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): FirStatement {
        return transformLoop(errorLoop, data)
    }

-    override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): CompositeTransformResult<FirReference> {
+    override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): FirReference {
        return transformNamedReference(errorNamedReference, data)
    }

-    override fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): CompositeTransformResult<FirStatement> {
+    override fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): FirStatement {
        return transformFunction(errorFunction, data)
    }

    override fun transformErrorResolvedQualifier(
        errorResolvedQualifier: FirErrorResolvedQualifier,
        data: D
-    ): CompositeTransformResult<FirStatement> {
+    ): FirStatement {
        return transformResolvedQualifier(errorResolvedQualifier, data)
    }

-    override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): CompositeTransformResult<FirStatement> {
+    override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): FirStatement {
        return transformFunctionCall(implicitInvokeCall, data)
    }
 }
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement

 fun <T : FirElement, D> T.transformSingle(transformer: FirTransformer<D>, data: D): T {
-    return (this as FirPureAbstractElement).transform<T, D>(transformer, data).single
+    return (this as FirPureAbstractElement).transform<T, D>(transformer, data)
 }

 fun <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirTransformer<D>, data: D) {
@@ -17,20 +17,7 @@ fun <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirTransfor
    while (iterator.hasNext()) {
        val next = iterator.next() as FirPureAbstractElement
        val result = next.transform<T, D>(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 <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirT
            is TransformData.Data<D> -> data.value
            TransformData.Nothing -> continue
        }
-        val result = next.transform<T, D>(transformer, data).single
+        val result = next.transform<T, D>(transformer, data)
        iterator.set(result)
    }
 }
@@ -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")
@@ -133,9 +133,9 @@ fun SmartPrinter.printElement(element: Element) {
                println("fun acceptChildren(visitor: FirVisitorVoid) = acceptChildren(visitor, null)")
                println()
                println("@Suppress(\"UNCHECKED_CAST\")")
-                println("fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): CompositeTransformResult<E> =")
+                println("fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): E =")
                withIndent {
-                    println("accept(visitor, data) as CompositeTransformResult<E>")
+                    println("accept(visitor, data) as E")
                }
                println()
                println("fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement")
@@ -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<Element>, generationPath: File): GeneratedFi
        println("package $VISITOR_PACKAGE")
        println()
        elements.forEach { println("import ${it.fullQualifiedName}") }
-        println("import ${compositeTransformResultType.fullQualifiedName}")
        println()
        printGeneratedMessage()

-        println("abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirElement>, D>() {")
+        println("abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {")
        println()
        withIndent {
-            println("abstract fun <E : FirElement> transformElement(element: E, data: D): CompositeTransformResult<E>")
+            println("abstract fun <E : FirElement> transformElement(element: E, data: D): E")
            println()
            for (element in elements) {
                if (element == AbstractFirTreeBuilder.baseFirElement) continue
@@ -37,8 +35,8 @@ fun printTransformer(elements: List<Element>, 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<Element>, 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)")
@@ -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<String> = emptyList(), kind: Import
 fun Element.collectImports(): List<String> {
    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!!
    }
@@ -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> {
+    ): FirSimpleFunction {
        FirLazyBodiesCalculator.calculateLazyBodiesForFunction(simpleFunction, declarationDesignation)
        return super.transformSimpleFunction(simpleFunction, data)
    }

-    override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
+    override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration {
        FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(constructor, declarationDesignation)
        return super.transformConstructor(constructor, data)
    }

-    override fun transformProperty(property: FirProperty, data: ResolutionMode): CompositeTransformResult<FirProperty> {
+    override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
        FirLazyBodiesCalculator.calculateLazyBodyForProperty(property, declarationDesignation)
        return super.transformProperty(property, data)
    }
@@ -101,14 +101,14 @@ internal object FirLazyBodiesCalculator {

 private object FirLazyBodiesCalculatorTransformer : FirTransformer<MutableList<FirDeclaration>>() {

-    override fun transformFile(file: FirFile, data: MutableList<FirDeclaration>): CompositeTransformResult<FirDeclaration> {
+    override fun transformFile(file: FirFile, data: MutableList<FirDeclaration>): FirDeclaration {
        file.declarations.forEach {
            it.transformSingle(this, data)
        }
-        return file.compose()
+        return file
    }

-    override fun <E : FirElement> transformElement(element: E, data: MutableList<FirDeclaration>): CompositeTransformResult<E> {
+    override fun <E : FirElement> transformElement(element: E, data: MutableList<FirDeclaration>): E {
        if (element is FirRegularClass) {
            data.add(element)
            element.declarations.forEach {
@@ -117,33 +117,33 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer<MutableList<F
            element.transformChildren(this, data)
            data.removeLast()
        }
-        return element.compose()
+        return element
    }

    override fun transformSimpleFunction(
        simpleFunction: FirSimpleFunction,
        data: MutableList<FirDeclaration>
-    ): CompositeTransformResult<FirDeclaration> {
+    ): FirDeclaration {
        if (simpleFunction.body is FirLazyBlock) {
            FirLazyBodiesCalculator.calculateLazyBodiesForFunction(simpleFunction, data)
        }
-        return simpleFunction.compose()
+        return simpleFunction
    }

    override fun transformConstructor(
        constructor: FirConstructor,
        data: MutableList<FirDeclaration>
-    ): CompositeTransformResult<FirDeclaration> {
+    ): FirDeclaration {
        if (constructor.body is FirLazyBlock) {
            FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(constructor, data)
        }
-        return constructor.compose()
+        return constructor
    }

-    override fun transformProperty(property: FirProperty, data: MutableList<FirDeclaration>): CompositeTransformResult<FirDeclaration> {
+    override fun transformProperty(property: FirProperty, data: MutableList<FirDeclaration>): FirDeclaration {
        if (FirLazyBodiesCalculator.needCalculatingLazyBodyForProperty(property)) {
            FirLazyBodiesCalculator.calculateLazyBodyForProperty(property, data)
        }
-        return property.compose()
+        return property
    }
 }
@@ -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<FirDeclaration> =
+    override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration =
        ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data ->
            super.transformDeclarationContent(declaration, data)
        }
@@ -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<FirDeclaration> =
+    override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration =
        ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data ->
            super.transformDeclarationContent(declaration, data)
        }
@@ -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<FirDeclaration> =
+    override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration =
        ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { declaration, data ->
            super.transformDeclarationContent(declaration, data)
        }
@@ -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<FirFile> {
+    override fun transformFile(file: FirFile, data: ResolutionMode): FirFile {
        return context.withFile(file, components) {
            file.transformAnnotations(this, data)
-            file.compose()
+            file
        }
    }

@@ -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<FirDeclaration>
-    ): CompositeTransformResult<FirDeclaration> {
+        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 <D> FirElement.visitNoTransform(transformer: FirTransformer<D>, data: D) {
    val result = this.transform<FirElement, D>(transformer, data)
-    require(result.single === this) { "become ${result.single}: `${result.single.render()}`, was ${this}: `${this.render()}`" }
+    require(result === this) { "become $result `${result.render()}`, was ${this}: `${this.render()}`" }
 }