Extract part of utility FIR transformers into TransformUtils

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt

@@ -696,7 +696,7 @@ open class FirBodyResolveTransformer(
             )
         }
 
-        qualifiedAccess.transformChildren(ReplaceInArguments, replacements.toMap())
+        qualifiedAccess.transformChildren(MapArguments, replacements.toMap())
 
 
         if (completionMode == KotlinConstraintSystemCompleter.ConstraintSystemCompletionMode.FULL) {
@@ -1132,23 +1132,9 @@ private fun inferenceComponents(session: FirSession, jump: ReturnTypeCalculatorW
 
 class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: ScopeSession) : ReturnTypeCalculator {
 
-
-    val storeType = object : FirTransformer<FirTypeRef>() {
-        override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
-            return element.compose()
-        }
-
-        override fun transformImplicitTypeRef(
-            implicitTypeRef: FirImplicitTypeRef,
-            data: FirTypeRef
-        ): CompositeTransformResult<FirTypeRef> {
-            return data.compose()
-        }
-    }
-
     private fun cycleErrorType(declaration: FirTypedDeclaration): FirResolvedTypeRef? {
         if (declaration.returnTypeRef is FirComputingImplicitTypeRef) {
-            declaration.transformReturnTypeRef(storeType, FirErrorTypeRefImpl(session, null, "cycle"))
+            declaration.transformReturnTypeRef(TransformImplicitType, FirErrorTypeRefImpl(session, null, "cycle"))
             return declaration.returnTypeRef as FirResolvedTypeRef
         }
         return null
@@ -1158,7 +1144,7 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc
 
         if (declaration is FirValueParameter && declaration.returnTypeRef is FirImplicitTypeRef) {
             // TODO?
-            declaration.transformReturnTypeRef(storeType, FirErrorTypeRefImpl(session, null, "Unsupported: implicit VP type"))
+            declaration.transformReturnTypeRef(TransformImplicitType, FirErrorTypeRefImpl(session, null, "Unsupported: implicit VP type"))
         }
         val returnTypeRef = declaration.returnTypeRef
         if (returnTypeRef is FirResolvedTypeRef) return returnTypeRef
@@ -1183,11 +1169,11 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc
             "I don't know what todo"
         )
 
-        declaration.transformReturnTypeRef(storeType, FirComputingImplicitTypeRef)
+        declaration.transformReturnTypeRef(TransformImplicitType, FirComputingImplicitTypeRef)
 
         val transformer = FirDesignatedBodyResolveTransformer(
             (listOf(file) + outerClasses.filterNotNull().asReversed() + listOf(declaration)).iterator(),
-            file.session,
+            file.fileSession,
             scopeSession
         )
 
@@ -1262,57 +1248,4 @@ interface ReturnTypeCalculator {
     fun tryCalculateReturnType(declaration: FirTypedDeclaration): FirResolvedTypeRef
 }
 
-private object StoreNameReference : FirTransformer<FirNamedReference>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): CompositeTransformResult<E> {
-        return element.compose()
-    }
 
-    override fun transformNamedReference(
-        namedReference: FirNamedReference,
-        data: FirNamedReference
-    ): CompositeTransformResult<FirNamedReference> {
-        return data.compose()
-    }
-}
-
-internal object StoreType : FirTransformer<FirTypeRef>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
-        return element.compose()
-    }
-
-    override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): CompositeTransformResult<FirTypeRef> {
-        return data.compose()
-    }
-}
-
-internal object StoreExplicitReceiver : FirTransformer<FirExpression>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirExpression): CompositeTransformResult<E> {
-        return element.compose()
-    }
-
-    override fun transformExpression(expression: FirExpression, data: FirExpression): CompositeTransformResult<FirStatement> {
-        return data.compose()
-    }
-
-
-}
-
-private object ReplaceInArguments : FirTransformer<Map<FirElement, FirElement>>() {
-    override fun <E : FirElement> transformElement(element: E, data: Map<FirElement, FirElement>): CompositeTransformResult<E> {
-        return ((data[element] ?: element) as E).compose()
-    }
-
-    override fun transformFunctionCall(
-        functionCall: FirFunctionCall,
-        data: Map<FirElement, FirElement>
-    ): CompositeTransformResult<FirStatement> {
-        return (functionCall.transformChildren(this, data) as FirStatement).compose()
-    }
-
-    override fun transformWrappedArgumentExpression(
-        wrappedArgumentExpression: FirWrappedArgumentExpression,
-        data: Map<FirElement, FirElement>
-    ): CompositeTransformResult<FirStatement> {
-        return (wrappedArgumentExpression.transformChildren(this, data) as FirStatement).compose()
-    }
-}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompleterTransformer.kt

@@ -27,19 +27,6 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.types.Variance
 
-object StoreCalleeReference : FirTransformer<FirResolvedCallableReference>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirResolvedCallableReference): CompositeTransformResult<E> {
-        return element.compose()
-    }
-
-    override fun transformResolvedCallableReference(
-        resolvedCallableReference: FirResolvedCallableReference,
-        data: FirResolvedCallableReference
-    ): CompositeTransformResult<FirNamedReference> {
-        return data.compose()
-    }
-}
-
 class FirCallCompleterTransformer(
     val session: FirSession,
     private val finalSubstitutor: ConeSubstitutor,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/TransformUtils.kt

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.resolve.transformers
+
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirNamedReference
+import org.jetbrains.kotlin.fir.FirResolvedCallableReference
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
+import org.jetbrains.kotlin.fir.expressions.FirStatement
+import org.jetbrains.kotlin.fir.expressions.FirWrappedArgumentExpression
+import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
+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
+
+internal object MapArguments : FirTransformer<Map<FirElement, FirElement>>() {
+    override fun <E : FirElement> transformElement(element: E, data: Map<FirElement, FirElement>): CompositeTransformResult<E> {
+        return ((data[element] ?: element) as E).compose()
+    }
+
+    override fun transformFunctionCall(
+        functionCall: FirFunctionCall,
+        data: Map<FirElement, FirElement>
+    ): CompositeTransformResult<FirStatement> {
+        return (functionCall.transformChildren(this, data) as FirStatement).compose()
+    }
+
+    override fun transformWrappedArgumentExpression(
+        wrappedArgumentExpression: FirWrappedArgumentExpression,
+        data: Map<FirElement, FirElement>
+    ): CompositeTransformResult<FirStatement> {
+        return (wrappedArgumentExpression.transformChildren(this, data) as FirStatement).compose()
+    }
+}
+
+internal object StoreType : FirTransformer<FirTypeRef>() {
+    override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
+        return element.compose()
+    }
+
+    override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): CompositeTransformResult<FirTypeRef> {
+        return data.compose()
+    }
+}
+
+internal object TransformImplicitType : FirTransformer<FirTypeRef>() {
+    override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
+        return element.compose()
+    }
+
+    override fun transformImplicitTypeRef(
+        implicitTypeRef: FirImplicitTypeRef,
+        data: FirTypeRef
+    ): CompositeTransformResult<FirTypeRef> {
+        return data.compose()
+    }
+}
+
+
+internal object StoreNameReference : FirTransformer<FirNamedReference>() {
+    override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): CompositeTransformResult<E> {
+        return element.compose()
+    }
+
+    override fun transformNamedReference(
+        namedReference: FirNamedReference,
+        data: FirNamedReference
+    ): CompositeTransformResult<FirNamedReference> {
+        return data.compose()
+    }
+}
+
+internal object StoreCalleeReference : FirTransformer<FirResolvedCallableReference>() {
+    override fun <E : FirElement> transformElement(element: E, data: FirResolvedCallableReference): CompositeTransformResult<E> {
+        return element.compose()
+    }
+
+    override fun transformResolvedCallableReference(
+        resolvedCallableReference: FirResolvedCallableReference,
+        data: FirResolvedCallableReference
+    ): CompositeTransformResult<FirNamedReference> {
+        return data.compose()
+    }
+}