[FIR] Remove default visited hierarchy

compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt

@@ -323,7 +323,7 @@ class MultiModuleHtmlFirDump(private val outputRoot: File) {
 
                 override fun visitRegularClass(regularClass: FirRegularClass) {
                     classes[regularClass.classId] = location
-                    super.visitRegularClass(regularClass)
+                    visitElement(regularClass)
                 }
 
                 fun indexDeclaration(symbolOwner: FirSymbolOwner<*>) {
@@ -333,32 +333,32 @@ class MultiModuleHtmlFirDump(private val outputRoot: File) {
 
                 override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>) {
                     indexDeclaration(variable)
-                    super.visitVariable(variable)
+                    visitElement(variable)
                 }
 
                 override fun visitValueParameter(valueParameter: FirValueParameter) {
                     indexDeclaration(valueParameter)
-                    super.visitValueParameter(valueParameter)
+                    visitElement(valueParameter)
                 }
 
                 override fun visitNamedFunction(namedFunction: FirNamedFunction) {
                     indexDeclaration(namedFunction)
-                    super.visitNamedFunction(namedFunction)
+                    visitElement(namedFunction)
                 }
 
                 override fun visitTypeParameter(typeParameter: FirTypeParameter) {
                     indexDeclaration(typeParameter)
-                    super.visitTypeParameter(typeParameter)
+                    visitElement(typeParameter)
                 }
 
                 override fun visitProperty(property: FirProperty) {
                     indexDeclaration(property)
-                    super.visitProperty(property)
+                    visitElement(property)
                 }
 
                 override fun visitConstructor(constructor: FirConstructor) {
                     indexDeclaration(constructor)
-                    super.visitConstructor(constructor)
+                    visitElement(constructor)
                 }
             }
         }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt

@@ -53,7 +53,7 @@ import org.jetbrains.kotlin.types.AbstractStrictEqualityTypeChecker
 import org.jetbrains.kotlin.types.Variance
 import java.util.*
 
-internal class Fir2IrVisitor(
+class Fir2IrVisitor(
     private val session: FirSession,
     private val moduleDescriptor: FirModuleDescriptor,
     private val symbolTable: SymbolTable,
@@ -297,6 +297,10 @@ internal class Fir2IrVisitor(
             }
     }
 
+    override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Any?): IrElement {
+        return visitRegularClass(enumEntry, data)
+    }
+
     private fun IrFunction.addDispatchReceiverParameter(containingClass: IrClass) {
         val thisOrigin = IrDeclarationOrigin.DEFINED
         val thisType = containingClass.thisReceiver!!.type
@@ -661,6 +665,18 @@ internal class Fir2IrVisitor(
         return wrappedArgumentExpression.expression.toIrExpression()
     }
 
+    override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: Any?): IrElement {
+        return visitWrappedArgumentExpression(namedArgumentExpression, data)
+    }
+
+    override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: Any?): IrElement {
+        return visitWrappedArgumentExpression(lambdaArgumentExpression, data)
+    }
+
+    override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: Any?): IrElement {
+        return visitWrappedArgumentExpression(spreadArgumentExpression, data)
+    }
+
     private fun FirReference.statementOrigin(): IrStatementOrigin? {
         return when (this) {
             is FirPropertyFromParameterCallableReference -> IrStatementOrigin.INITIALIZE_PROPERTY_FROM_PARAMETER
@@ -793,6 +809,10 @@ internal class Fir2IrVisitor(
         return functionCall.toIrExpression(functionCall.typeRef).applyCallArguments(functionCall).applyReceivers(functionCall)
     }
 
+    override fun visitComponentCall(componentCall: FirComponentCall, data: Any?): IrElement {
+        return visitFunctionCall(componentCall, data)
+    }
+
     override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): IrElement {
         return annotationCall.toIrExpression().applyCallArguments(annotationCall)
     }
@@ -1249,7 +1269,7 @@ internal class Fir2IrVisitor(
                 )
             }
         }
-        return super.visitResolvedQualifier(resolvedQualifier, data)
+        return visitElement(resolvedQualifier, data)
     }
 
     override fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: Any?): IrElement {

compiler/fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTotalKotlinTestCase.kt

@@ -80,7 +80,7 @@ class RawFirBuilderTotalKotlinTestCase : AbstractRawFirBuilderTestCase() {
                         } else {
                             normalReferences++
                         }
-                        super.visitQualifiedAccess(qualifiedAccess)
+                        visitStatement(qualifiedAccess)
                     }
 
                     override fun visitExpression(expression: FirExpression) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt

@@ -102,6 +102,10 @@ class FirProviderImpl(val session: FirSession) : FirProvider() {
             override fun visitProperty(property: FirProperty) {
                 visitCallableMemberDeclaration(property)
             }
+
+            override fun visitEnumEntry(enumEntry: FirEnumEntry) {
+                visitRegularClass(enumEntry)
+            }
         })
     }
 

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

@@ -101,7 +101,7 @@ open class FirBodyResolveTransformer(
         return withScopeCleanup(topLevelScopes) {
             topLevelScopes.addImportingScopes(file, session, scopeSession)
             topLevelScopes += FirTopLevelDeclaredMemberScope(file, session, scopeSession)
-            super.transformFile(file, data)
+            transformElement(file, data)
         }
     }
 
@@ -112,7 +112,7 @@ open class FirBodyResolveTransformer(
 
     override fun transformConstructor(constructor: FirConstructor, data: Any?): CompositeTransformResult<FirDeclaration> {
         if (implicitTypeOnly) return constructor.compose()
-        return super.transformConstructor(constructor, data)
+        return transformFunction(constructor, data)
     }
 
     override fun transformAnonymousInitializer(
@@ -123,7 +123,7 @@ open class FirBodyResolveTransformer(
         return withScopeCleanup(localScopes) {
             dataFlowAnalyzer.enterInitBlock(anonymousInitializer)
             localScopes.addIfNotNull(primaryConstructorParametersScope)
-            super.transformAnonymousInitializer(anonymousInitializer, data).also {
+            transformDeclaration(anonymousInitializer, data).also {
                 dataFlowAnalyzer.exitInitBlock(it.single as FirAnonymousInitializer)
             }
         }
@@ -142,7 +142,7 @@ open class FirBodyResolveTransformer(
             valueParameter.resolvePhase = transformerPhase
             return valueParameter.compose() // TODO
         }
-        return super.transformValueParameter(valueParameter, valueParameter.returnTypeRef)
+        return transformDeclaration(valueParameter, valueParameter.returnTypeRef)
     }
 
     override fun transformRegularClass(regularClass: FirRegularClass, data: Any?): CompositeTransformResult<FirDeclaration> {
@@ -156,17 +156,21 @@ open class FirBodyResolveTransformer(
                     constructor.valueParameters.forEach { this.storeDeclaration(it) }
                 }
             }
-            super.transformRegularClass(regularClass, data)
+            transformDeclaration(regularClass, data)
         }
         primaryConstructorParametersScope = oldConstructorScope
         return result
     }
 
+    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Any?): CompositeTransformResult<FirDeclaration> {
+        return transformRegularClass(enumEntry, data)
+    }
+
     override fun transformUncheckedNotNullCast(
         uncheckedNotNullCast: FirUncheckedNotNullCast,
         data: Any?
     ): CompositeTransformResult<FirStatement> {
-        val notNullCast = super.transformUncheckedNotNullCast(uncheckedNotNullCast, data).single as FirUncheckedNotNullCast
+        val notNullCast = transformExpression(uncheckedNotNullCast, data).single as FirUncheckedNotNullCast
         val resultType = notNullCast.expression.resultType
         notNullCast.resultType =
             resultType.withReplacedConeType(resultType.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NOT_NULL))
@@ -268,6 +272,13 @@ open class FirBodyResolveTransformer(
         }
     }
 
+    override fun transformCallableReferenceAccess(
+        callableReferenceAccess: FirCallableReferenceAccess,
+        data: Any?
+    ): CompositeTransformResult<FirStatement> {
+        return transformQualifiedAccessExpression(callableReferenceAccess, data)
+    }
+
     override fun transformVariableAssignment(
         variableAssignment: FirVariableAssignment,
         data: Any?
@@ -350,7 +361,7 @@ open class FirBodyResolveTransformer(
                 )
                 af = af.transformValueParameters(ImplicitToErrorTypeTransformer, null) as FirAnonymousFunction
                 val bodyExpectedType = returnTypeRefFromResolvedAtom ?: data
-                af = super.transformAnonymousFunction(af, bodyExpectedType).single as FirAnonymousFunction
+                af = transformFunction(af, bodyExpectedType).single as FirAnonymousFunction
                 af = af.copy(
                     returnTypeRef = af.body?.resultType ?: FirErrorTypeRefImpl(af.psi, "No result type for lambda")
                 )
@@ -358,7 +369,7 @@ open class FirBodyResolveTransformer(
                 af.compose()
             }
             else -> {
-                super.transformAnonymousFunction(anonymousFunction, data)
+                transformFunction(anonymousFunction, data)
             }
         }
     }
@@ -385,8 +396,8 @@ open class FirBodyResolveTransformer(
         val receiverTypeRef = anonymousFunction.receiverTypeRef
         fun transform(): FirAnonymousFunction {
             val expectedReturnType =
-                    lambdaResolution.expectedReturnTypeRef ?: anonymousFunction.returnTypeRef.takeUnless { it is FirImplicitTypeRef }
+                lambdaResolution.expectedReturnTypeRef ?: anonymousFunction.returnTypeRef.takeUnless { it is FirImplicitTypeRef }
-                val result = super.transformAnonymousFunction(anonymousFunction, expectedReturnType).single as FirAnonymousFunction
+            val result = transformFunction(anonymousFunction, expectedReturnType).single as FirAnonymousFunction
             val body = result.body
             return if (result.returnTypeRef is FirImplicitTypeRef && body != null) {
                 result.transformReturnTypeRef(this, body.resultType)
@@ -475,7 +486,11 @@ open class FirBodyResolveTransformer(
 
     }
 
-//    override fun transformNamedReference(namedReference: FirNamedReference, data: Any?): CompositeTransformResult<FirNamedReference> {
+    override fun transformComponentCall(componentCall: FirComponentCall, data: Any?): CompositeTransformResult<FirStatement> {
+        return transformFunctionCall(componentCall, data)
+    }
+
+    //    override fun transformNamedReference(namedReference: FirNamedReference, data: Any?): CompositeTransformResult<FirNamedReference> {
 //        if (namedReference is FirErrorNamedReference || namedReference is FirResolvedCallableReference) return namedReference.compose()
 //        val referents = data as? List<ConeCallableSymbol> ?: return namedReference.compose()
 //        return createResolvedNamedReference(namedReference, referents).compose()
@@ -503,13 +518,28 @@ open class FirBodyResolveTransformer(
     }
 
     override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: Any?): CompositeTransformResult<FirStatement> {
-        val result = super.transformJump(jump, data)
+        val result = transformExpression(jump, data)
         dataFlowAnalyzer.exitJump(jump)
         return result
     }
 
+    override fun transformBreakExpression(breakExpression: FirBreakExpression, data: Any?): CompositeTransformResult<FirStatement> {
+        return transformJump(breakExpression, data)
+    }
+
+    override fun transformContinueExpression(
+        continueExpression: FirContinueExpression,
+        data: Any?
+    ): CompositeTransformResult<FirStatement> {
+        return transformJump(continueExpression, data)
+    }
+
+    override fun transformReturnExpression(returnExpression: FirReturnExpression, data: Any?): CompositeTransformResult<FirStatement> {
+        return transformJump(returnExpression, data)
+    }
+
     override fun transformThrowExpression(throwExpression: FirThrowExpression, data: Any?): CompositeTransformResult<FirStatement> {
-        return super.transformThrowExpression(throwExpression, data).also {
+        return transformExpression(throwExpression, data).also {
             dataFlowAnalyzer.exitThrowExceptionNode(it.single as FirThrowExpression)
         }
     }
@@ -606,7 +636,7 @@ open class FirBodyResolveTransformer(
         }
 
 
-        return super.transformConstExpression(constExpression, data).also {
+        return transformExpression(constExpression, data).also {
             dataFlowAnalyzer.exitConstExpresion(it.single as FirConstExpression<*>)
         }
     }
@@ -628,7 +658,7 @@ open class FirBodyResolveTransformer(
         return withScopeCleanup(localScopes) {
             localScopes += FirLocalScope()
             dataFlowAnalyzer.enterFunction(function)
-            super.transformFunction(function, data).also {
+            transformDeclaration(function, data).also {
                 val result = it.single as FirFunction<*>
                 dataFlowAnalyzer.exitFunction(result)?.let { controlFlowGraph ->
                     result.transformControlFlowGraphReference(ControlFlowGraphReferenceTransformer, controlFlowGraph)
@@ -678,7 +708,7 @@ open class FirBodyResolveTransformer(
 
     override fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: Any?): CompositeTransformResult<FirDeclaration> {
         if (propertyAccessor is FirDefaultPropertyAccessor || propertyAccessor.body == null) {
-            return super.transformPropertyAccessor(propertyAccessor, data)
+            return transformFunction(propertyAccessor, data)
         }
         val returnTypeRef = propertyAccessor.returnTypeRef
         if (returnTypeRef is FirImplicitTypeRef && data !is FirResolvedTypeRef) {
@@ -748,7 +778,7 @@ open class FirBodyResolveTransformer(
         wrappedDelegateExpression: FirWrappedDelegateExpression,
         data: Any?
     ): CompositeTransformResult<FirStatement> {
-        super.transformWrappedDelegateExpression(wrappedDelegateExpression, data)
+        transformExpression(wrappedDelegateExpression, data)
         with(wrappedDelegateExpression) {
             val delegateProviderTypeRef = delegateProvider.typeRef
             val useDelegateProvider = delegateProviderTypeRef is FirResolvedTypeRef &&
@@ -812,7 +842,7 @@ open class FirBodyResolveTransformer(
     }
 
     override fun transformGetClassCall(getClassCall: FirGetClassCall, data: Any?): CompositeTransformResult<FirStatement> {
-        val transformedGetClassCall = super.transformGetClassCall(getClassCall, data).single as FirGetClassCall
+        val transformedGetClassCall = transformExpression(getClassCall, data).single as FirGetClassCall
         val kClassSymbol = ClassId.fromString("kotlin/reflect/KClass")(session.service())
 
         val typeOfExpression = when (val lhs = transformedGetClassCall.argument) {
@@ -870,7 +900,7 @@ open class FirBodyResolveTransformer(
                 it.resultType = builtinTypes.booleanType
             }
         } else {
-            super.transformOperatorCall(operatorCall, data).single
+            transformExpression(operatorCall, data).single
         } as FirOperatorCall
         dataFlowAnalyzer.exitOperatorCall(result)
         return result.compose()

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.copy
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
 import org.jetbrains.kotlin.fir.resolve.calls.candidate
@@ -58,6 +57,13 @@ class FirCallCompletionResultsWriterTransformer(
         ).compose()
     }
 
+    override fun transformCallableReferenceAccess(
+        callableReferenceAccess: FirCallableReferenceAccess,
+        data: Nothing?
+    ): CompositeTransformResult<FirStatement> {
+        return transformQualifiedAccessExpression(callableReferenceAccess, data)
+    }
+
     override fun transformVariableAssignment(
         variableAssignment: FirVariableAssignment,
         data: Nothing?
@@ -131,6 +137,10 @@ class FirCallCompletionResultsWriterTransformer(
 
     }
 
+    override fun transformComponentCall(componentCall: FirComponentCall, data: Nothing?): CompositeTransformResult<FirStatement> {
+        return transformFunctionCall(componentCall, data)
+    }
+
     override fun transformAnonymousFunction(
         anonymousFunction: FirAnonymousFunction,
         data: Nothing?
@@ -145,7 +155,7 @@ class FirCallCompletionResultsWriterTransformer(
 
             anonymousFunction.replaceTypeRef(anonymousFunction.constructFunctionalTypeRef(session))
         }
-        return super.transformAnonymousFunction(anonymousFunction, data)
+        return transformElement(anonymousFunction, data)
     }
 
     override fun transformBlock(block: FirBlock, data: Nothing?): CompositeTransformResult<FirStatement> {
@@ -155,7 +165,7 @@ class FirCallCompletionResultsWriterTransformer(
             val resultType = block.resultType.withReplacedConeType(finalType)
             block.replaceTypeRef(resultType)
         }
-        return super.transformBlock(block, data)
+        return transformElement(block, data)
     }
 
     override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Nothing?): CompositeTransformResult<FirStatement> {

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

@@ -58,4 +58,34 @@ class FirSpecificTypeResolverTransformer(
     override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
         return implicitTypeRef.compose()
     }
+
+    override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(errorTypeRef, data)
+    }
+
+    override fun transformResolvedFunctionTypeRef(
+        resolvedFunctionTypeRef: FirResolvedFunctionTypeRef,
+        data: Nothing?
+    ): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(resolvedFunctionTypeRef, data)
+    }
+
+    override fun transformTypeRefWithNullability(
+        typeRefWithNullability: FirTypeRefWithNullability,
+        data: Nothing?
+    ): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(typeRefWithNullability, data)
+    }
+
+    override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(userTypeRef, data)
+    }
+
+    override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(dynamicTypeRef, data)
+    }
+
+    override fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(delegatedTypeRef, data)
+    }
 }

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

@@ -63,7 +63,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
 
     override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
         session = file.fileSession
-        return super.transformFile(file, data)
+        return transformElement(file, data)
     }
 
     override fun transformDeclarationStatus(
@@ -81,7 +81,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
             return resolvedStatus.compose()
         }
 
-        return super.transformDeclarationStatus(declarationStatus, data)
+        return transformElement(declarationStatus, data)
     }
 
     private inline fun storeDeclaration(
@@ -104,9 +104,13 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
         return result
     }
 
+    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        return transformMemberDeclaration(typeAlias, data)
+    }
+
     override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirDeclaration> {
         return storeClass(regularClass) {
-            super.transformRegularClass(regularClass, data)
+            transformMemberDeclaration(regularClass, data)
         }
     }
 
@@ -115,7 +119,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
         data: Nothing?
     ): CompositeTransformResult<FirDeclaration> {
         return storeDeclaration(memberDeclaration) {
-            super.transformMemberDeclaration(memberDeclaration, data)
+            transformDeclaration(memberDeclaration, data)
         }
     }
 
@@ -124,7 +128,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
         data: Nothing?
     ): CompositeTransformResult<FirDeclaration> {
         return storeDeclaration(propertyAccessor) {
-            super.transformPropertyAccessor(propertyAccessor, data)
+            transformDeclaration(propertyAccessor, data)
         }
     }
 
@@ -133,7 +137,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
         data: Nothing?
     ): CompositeTransformResult<FirDeclaration> {
         return storeDeclaration(constructor) {
-            super.transformConstructor(constructor, data)
+            transformDeclaration(constructor, data)
         }
     }
 
@@ -142,7 +146,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
         data: Nothing?
     ): CompositeTransformResult<FirDeclaration> {
         return storeDeclaration(namedFunction) {
-            super.transformNamedFunction(namedFunction, data)
+            transformDeclaration(namedFunction, data)
         }
     }
 
@@ -151,7 +155,15 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
         data: Nothing?
     ): CompositeTransformResult<FirDeclaration> {
         return storeDeclaration(property) {
-            super.transformProperty(property, data)
+            transformDeclaration(property, data)
         }
     }
+
+    override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        return transformDeclaration(valueParameter, data)
+    }
+
+    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        return transformRegularClass(enumEntry, data)
+    }
 }

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

@@ -8,11 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.resolve.FirProvider
+import org.jetbrains.kotlin.fir.resolve.*
-import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
 import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.addImportingScopes
 import org.jetbrains.kotlin.fir.scopes.impl.FirNestedClassifierScope
@@ -31,7 +27,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
 
     override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
         initFromFile(file)
-        return super.transformFile(file, data)
+        return transformElement(file, data)
     }
 
     fun initFromFile(file: FirFile) {
@@ -43,7 +39,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
         val transformedClass = resolveSupertypesOrExpansions(regularClass) as? FirRegularClass ?: regularClass
 
         // resolve supertypes for nested classes
-        return super.transformRegularClass(transformedClass, data)
+        return transformElement(transformedClass, data)
     }
 
 
@@ -53,17 +49,36 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
     }
 
     // This and transformProperty functions are required to forbid supertype resolving for local classes
-    override fun transformDeclarationWithBody(
+//    override fun transformDeclarationWithBody(
-        declarationWithBody: FirDeclarationWithBody,
+//        declarationWithBody: FirDeclarationWithBody,
+//        data: Nothing?
+//    ): CompositeTransformResult<FirDeclaration> {
+//        return declarationWithBody.compose()
+//    }
+
+    override fun transformAnonymousInitializer(
+        anonymousInitializer: FirAnonymousInitializer,
         data: Nothing?
     ): CompositeTransformResult<FirDeclaration> {
-        return declarationWithBody.compose()
+        return anonymousInitializer.compose()
+    }
+
+    override fun transformConstructor(constructor: FirConstructor, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        return constructor.compose()
+    }
+
+    override fun transformNamedFunction(namedFunction: FirNamedFunction, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        return namedFunction.compose()
     }
 
     override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult<FirDeclaration> {
         return property.compose()
     }
 
+    override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        return function.compose()
+    }
+
     private fun resolveSupertypesOrExpansions(classLikeDeclaration: FirClassLikeDeclaration<*>): FirDeclaration {
         if (classLikeDeclaration.areSupertypesComputed() || classLikeDeclaration.areSupertypesComputing()) {
             return classLikeDeclaration
@@ -114,6 +129,10 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
             return resolveNestedClassesSupertypes(transformedClass, data)
         }
 
+        override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+            return transformRegularClass(enumEntry, data)
+        }
+
         private fun FirClassLikeDeclaration<*>.matchesRequestedDeclaration(): Boolean {
             if (knownFirClassLikeDeclaration != null) return knownFirClassLikeDeclaration == this
             return symbol.classId == requestedClassId
@@ -209,7 +228,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
                 towerScope.scopes += FirNestedClassifierScope(classId, firProvider)
                 regularClass.addTypeParametersScope()
 
-                super.transformRegularClass(regularClass, data)
+                transformElement(regularClass, data)
             }
         }
     }

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

@@ -13,7 +13,8 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
 import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.addImportingScopes
-import org.jetbrains.kotlin.fir.scopes.impl.*
+import org.jetbrains.kotlin.fir.scopes.impl.FirNestedClassifierScope
+import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
@@ -30,7 +31,7 @@ open class FirTypeResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(
         val scopeSession = ScopeSession()
         return withScopeCleanup {
             towerScope.addImportingScopes(file, session, scopeSession)
-            super.transformFile(file, data)
+            transformElement(file, data)
         }
     }
 
@@ -57,21 +58,21 @@ open class FirTypeResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(
             towerScope.scopes += FirNestedClassifierScope(classId, firProvider)
             regularClass.addTypeParametersScope()
 
-            super.transformRegularClass(regularClass, data)
+            transformDeclaration(regularClass, data)
         }
     }
 
     override fun transformConstructor(constructor: FirConstructor, data: Nothing?): CompositeTransformResult<FirDeclaration> {
         return withScopeCleanup {
             constructor.addTypeParametersScope()
-            super.transformConstructor(constructor, data)
+            transformDeclaration(constructor, data)
         }
     }
 
     override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> {
         return withScopeCleanup {
             typeAlias.addTypeParametersScope()
-            super.transformTypeAlias(typeAlias, data)
+            transformDeclaration(typeAlias, data)
         }
     }
 
@@ -79,28 +80,66 @@ open class FirTypeResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(
     override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult<FirDeclaration> {
         return withScopeCleanup {
             property.addTypeParametersScope()
-            super.transformProperty(property, data)
+            transformDeclaration(property, data)
         }
     }
 
     override fun transformNamedFunction(namedFunction: FirNamedFunction, data: Nothing?): CompositeTransformResult<FirDeclaration> {
         return withScopeCleanup {
             namedFunction.addTypeParametersScope()
-            super.transformNamedFunction(namedFunction, data)
+            transformDeclaration(namedFunction, data)
         }
     }
 
     override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
-        if (implicitTypeRef is FirImplicitBuiltinTypeRef) return super.transformImplicitTypeRef(implicitTypeRef, data)
+        if (implicitTypeRef is FirImplicitBuiltinTypeRef) return transformTypeRef(implicitTypeRef, data)
         return implicitTypeRef.compose()
     }
 
+    override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(resolvedTypeRef, data)
+    }
+
+    override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(errorTypeRef, data)
+    }
+
+    override fun transformResolvedFunctionTypeRef(
+        resolvedFunctionTypeRef: FirResolvedFunctionTypeRef,
+        data: Nothing?
+    ): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(resolvedFunctionTypeRef, data)
+    }
+
+    override fun transformTypeRefWithNullability(
+        typeRefWithNullability: FirTypeRefWithNullability,
+        data: Nothing?
+    ): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(typeRefWithNullability, data)
+    }
+
+    override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(userTypeRef, data)
+    }
+
+    override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(dynamicTypeRef, data)
+    }
+
+    override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(functionTypeRef, data)
+    }
+
+    override fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(delegatedTypeRef, data)
+    }
+
     override fun transformTypeRef(typeRef: FirTypeRef, data: Nothing?): CompositeTransformResult<FirTypeRef> {
         return FirSpecificTypeResolverTransformer(towerScope, FirPosition.OTHER, session).transformTypeRef(typeRef, data)
     }
 
     override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult<FirDeclaration> {
-        val result = super.transformValueParameter(valueParameter, data).single as FirValueParameter
+        val result = transformDeclaration(valueParameter, data).single as FirValueParameter
         if (result.isVararg) {
             val returnTypeRef = result.returnTypeRef
             val returnType = returnTypeRef.coneTypeUnsafe<ConeKotlinType>()

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

@@ -0,0 +1,60 @@
+/*
+ * 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.types.*
+import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.compose
+
+abstract class FirTypeTransformer<D> : FirTransformer<D>() {
+    override fun <E : FirElement> transformElement(element: E, data: D): CompositeTransformResult<E> {
+        return element.compose()
+    }
+
+    override fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformElement(typeRef, data)
+    }
+
+    override fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(delegatedTypeRef, data)
+    }
+
+    override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(implicitTypeRef, data)
+    }
+
+    override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(resolvedTypeRef, data)
+    }
+
+    override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformResolvedTypeRef(errorTypeRef, data)
+    }
+
+    override fun transformResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformResolvedTypeRef(resolvedFunctionTypeRef, data)
+    }
+
+    override fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRef(typeRefWithNullability, data)
+    }
+
+    override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRefWithNullability(dynamicTypeRef, data)
+    }
+
+    override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRefWithNullability(functionTypeRef, data)
+    }
+
+    override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
+        return transformTypeRefWithNullability(userTypeRef, data)
+    }
+
+
+}

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

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.FirNamedReference
 import org.jetbrains.kotlin.fir.FirResolvedCallableReference
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
-import org.jetbrains.kotlin.fir.resolve.calls.Candidate
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
@@ -35,23 +34,36 @@ internal object MapArguments : FirTransformer<Map<FirElement, FirElement>>() {
     ): CompositeTransformResult<FirStatement> {
         return (wrappedArgumentExpression.transformChildren(this, data) as FirStatement).compose()
     }
-}
 
-internal object StoreType : FirTransformer<FirTypeRef>() {
+    override fun transformLambdaArgumentExpression(
-    override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
+        lambdaArgumentExpression: FirLambdaArgumentExpression,
-        return element.compose()
+        data: Map<FirElement, FirElement>
+    ): CompositeTransformResult<FirStatement> {
+        return transformWrappedArgumentExpression(lambdaArgumentExpression, data)
     }
 
+    override fun transformSpreadArgumentExpression(
+        spreadArgumentExpression: FirSpreadArgumentExpression,
+        data: Map<FirElement, FirElement>
+    ): CompositeTransformResult<FirStatement> {
+        return transformWrappedArgumentExpression(spreadArgumentExpression, data)
+    }
+
+    override fun transformNamedArgumentExpression(
+        namedArgumentExpression: FirNamedArgumentExpression,
+        data: Map<FirElement, FirElement>
+    ): CompositeTransformResult<FirStatement> {
+        return transformWrappedArgumentExpression(namedArgumentExpression, data)
+    }
+}
+
+internal object StoreType : FirTypeTransformer<FirTypeRef>() {
     override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): CompositeTransformResult<FirTypeRef> {
         return data.compose()
     }
 }
 
-internal object TransformImplicitType : FirTransformer<FirTypeRef>() {
+internal object TransformImplicitType : FirTypeTransformer<FirTypeRef>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
-        return element.compose()
-    }
-
     override fun transformImplicitTypeRef(
         implicitTypeRef: FirImplicitTypeRef,
         data: FirTypeRef
@@ -61,11 +73,7 @@ internal object TransformImplicitType : FirTransformer<FirTypeRef>() {
 }
 
 
-internal object StoreNameReference : FirTransformer<FirNamedReference>() {
+internal object StoreNameReference : FirTypeTransformer<FirNamedReference>() {
-    override fun <E : FirElement> transformElement(element: E, data: FirNamedReference): CompositeTransformResult<E> {
-        return element.compose()
-    }
-
     override fun transformNamedReference(
         namedReference: FirNamedReference,
         data: FirNamedReference

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirCfgBuildingTest.kt

@@ -69,7 +69,7 @@ abstract class AbstractFirCfgBuildingTest : AbstractFirResolveTestCase() {
                 .appendln("${INDENT}node [shape=box penwidth=2]")
                 .appendln("${INDENT}edge [penwidth=2]")
                 .appendln()
-            super.visitFile(file)
+            visitElement(file)
             dotBuilder.appendln("}")
         }
 

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt

@@ -8,6 +8,8 @@ import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
+import org.jetbrains.kotlin.fir.expressions.FirComponentCall
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.resolve.FirProvider
@@ -197,7 +199,11 @@ class FirResolveBench(val withProgress: Boolean) {
                             }
                         }
 
-                        super.visitFunctionCall(functionCall)
+                        visitElement(functionCall)
+                    }
+
+                    override fun visitComponentCall(componentCall: FirComponentCall) {
+                        visitFunctionCall(componentCall)
                     }
 
                     override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) {
@@ -209,7 +215,11 @@ class FirResolveBench(val withProgress: Boolean) {
                             }
                         }
 
-                        super.visitQualifiedAccessExpression(qualifiedAccessExpression)
+                        visitElement(qualifiedAccessExpression)
+                    }
+
+                    override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
+                        visitQualifiedAccessExpression(callableReferenceAccess)
                     }
 
                     override fun visitTypeRef(typeRef: FirTypeRef) {
@@ -222,6 +232,34 @@ class FirResolveBench(val withProgress: Boolean) {
                         }
                     }
 
+                    override fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef) {
+                        visitTypeRef(delegatedTypeRef)
+                    }
+
+                    override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {
+                        visitResolvedTypeRef(errorTypeRef)
+                    }
+
+                    override fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef) {
+                        visitResolvedTypeRef(resolvedFunctionTypeRef)
+                    }
+
+                    override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) {
+                        visitTypeRef(typeRefWithNullability)
+                    }
+
+                    override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) {
+                        visitTypeRefWithNullability(dynamicTypeRef)
+                    }
+
+                    override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) {
+                        visitTypeRefWithNullability(functionTypeRef)
+                    }
+
+                    override fun visitUserTypeRef(userTypeRef: FirUserTypeRef) {
+                        visitTypeRefWithNullability(userTypeRef)
+                    }
+
                     override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) {
                         if (implicitTypeRef is FirResolvedTypeRef) {
                             visitResolvedTypeRef(implicitTypeRef)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -72,7 +72,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
     override fun visitFile(file: FirFile) {
         println("FILE: ${file.name}")
         pushIndent()
-        super.visitFile(file)
+        visitElement(file)
         popIndent()
     }
 

compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt

@@ -90,7 +90,7 @@ class ParametricTransformerGenerator(data: DataCollector.ReferencesData) : Abstr
                 typeParametersWithBounds = listOf("E : $parent") + className.typeParametersWithBounds()
             ) {
                 print("return ")
-                generateCall("transform${parent.name.classNameWithoutFir}", listOf(parameterName, "data"))
+                generateCall("transformElement", listOf(parameterName, "data"))
                 printlnWithNoIndent()
             }
         } else {
@@ -104,7 +104,7 @@ class ParametricTransformerGenerator(data: DataCollector.ReferencesData) : Abstr
                 typeParametersWithBounds = className.typeParametersWithBounds()
             ) {
                 print("return ")
-                generateCall("transform${parent.name.classNameWithoutFir}", listOf(parameterName, "data"))
+                generateCall("transformElement", listOf(parameterName, "data"))
                 printlnWithNoIndent()
             }
         }

compiler/fir/tree/visitors-generator/src/SimpleVisitorGenerator.kt

@@ -46,7 +46,7 @@ class SimpleVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abs
             typeParametersWithBounds = className.typeParametersWithBounds()
         ) {
             print("return ")
-            generateCall("visit${parent.name.classNameWithoutFir}", listOf(parameterName, "data"))
+            generateCall("visitElement", listOf(parameterName, "data"))
             println()
         }
     }

compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt

@@ -49,7 +49,7 @@ class UnitVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abstr
             typeParametersWithBounds = className.typeParametersWithBounds()
         ) {
             printIndent()
-            generateCall("visit${parent.name.classNameWithoutFir}", listOf(parameterName, "null"))
+            generateCall("visitElement", listOf(parameterName, "null"))
             println()
         }
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt

@@ -26,99 +26,99 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
     }
 
     open fun <F : FirCallableDeclaration<F>> transformCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclaration(callableDeclaration, data)
+        return transformElement(callableDeclaration, data)
     }
 
     open fun <F : FirCallableMemberDeclaration<F>> transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclaration(callableMemberDeclaration, data)
+        return transformElement(callableMemberDeclaration, data)
     }
 
     open fun transformDeclarationWithBody(declarationWithBody: FirDeclarationWithBody, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclaration(declarationWithBody, data)
+        return transformElement(declarationWithBody, data)
     }
 
     open fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclarationWithBody(anonymousInitializer, data)
+        return transformElement(anonymousInitializer, data)
     }
 
     open fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclarationWithBody(function, data)
+        return transformElement(function, data)
     }
 
     open fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformFunction(anonymousFunction, data)
+        return transformElement(anonymousFunction, data)
     }
 
     open fun <F : FirMemberFunction<F>> transformMemberFunction(memberFunction: FirMemberFunction<F>, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformFunction(memberFunction, data)
+        return transformElement(memberFunction, data)
     }
 
     open fun transformConstructor(constructor: FirConstructor, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformMemberFunction(constructor, data)
+        return transformElement(constructor, data)
     }
 
     open fun transformNamedFunction(namedFunction: FirNamedFunction, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformMemberFunction(namedFunction, data)
+        return transformElement(namedFunction, data)
     }
 
     open fun <F : FirFunction<F>> transformModifiableFunction(modifiableFunction: FirModifiableFunction<F>, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformFunction(modifiableFunction, data)
+        return transformElement(modifiableFunction, data)
     }
 
     open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformFunction(propertyAccessor, data)
+        return transformElement(propertyAccessor, data)
     }
 
     open fun transformErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclaration(errorDeclaration, data)
+        return transformElement(errorDeclaration, data)
     }
 
     open fun transformField(field: FirField, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclaration(field, data)
+        return transformElement(field, data)
     }
 
     open fun transformNamedDeclaration(namedDeclaration: FirNamedDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclaration(namedDeclaration, data)
+        return transformElement(namedDeclaration, data)
     }
 
     open fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformNamedDeclaration(memberDeclaration, data)
+        return transformElement(memberDeclaration, data)
     }
 
     open fun <F : FirClassLikeDeclaration<F>> transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformMemberDeclaration(classLikeDeclaration, data)
+        return transformElement(classLikeDeclaration, data)
     }
 
     open fun transformRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformClassLikeDeclaration(regularClass, data)
+        return transformElement(regularClass, data)
     }
 
     open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformRegularClass(enumEntry, data)
+        return transformElement(enumEntry, data)
     }
 
     open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformClassLikeDeclaration(typeAlias, data)
+        return transformElement(typeAlias, data)
     }
 
     open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformNamedDeclaration(typeParameter, data)
+        return transformElement(typeParameter, data)
     }
 
     open fun transformProperty(property: FirProperty, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclaration(property, data)
+        return transformElement(property, data)
     }
 
     open fun transformTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclaration(typedDeclaration, data)
+        return transformElement(typedDeclaration, data)
     }
 
     open fun transformValueParameter(valueParameter: FirValueParameter, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclaration(valueParameter, data)
+        return transformElement(valueParameter, data)
     }
 
     open fun <F : FirVariable<F>> transformVariable(variable: FirVariable<F>, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformDeclaration(variable, data)
+        return transformElement(variable, data)
     }
 
     open fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): CompositeTransformResult<FirDeclarationStatus> {
@@ -126,7 +126,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
     }
 
     open fun transformResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): CompositeTransformResult<FirDeclarationStatus> {
-        return transformDeclarationStatus(resolvedDeclarationStatus, data)
+        return transformElement(resolvedDeclarationStatus, data)
     }
 
     open fun transformImport(import: FirImport, data: D): CompositeTransformResult<FirImport> {
@@ -134,7 +134,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
     }
 
     open fun transformResolvedImport(resolvedImport: FirResolvedImport, data: D): CompositeTransformResult<FirImport> {
-        return transformImport(resolvedImport, data)
+        return transformElement(resolvedImport, data)
     }
 
     open fun <E : FirElement> transformLabel(label: E, data: D): CompositeTransformResult<E> {
@@ -146,7 +146,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
     }
 
     open fun transformFile(file: FirFile, data: D): CompositeTransformResult<FirFile> {
-        return transformPackageFragment(file, data)
+        return transformElement(file, data)
     }
 
     open fun <E : FirElement> transformReference(reference: E, data: D): CompositeTransformResult<E> {
@@ -154,31 +154,31 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
     }
 
     open fun transformControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): CompositeTransformResult<FirControlFlowGraphReference> {
-        return transformReference(controlFlowGraphReference, data)
+        return transformElement(controlFlowGraphReference, data)
     }
 
     open fun transformNamedReference(namedReference: FirNamedReference, data: D): CompositeTransformResult<FirNamedReference> {
-        return transformReference(namedReference, data)
+        return transformElement(namedReference, data)
     }
 
     open fun transformResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): CompositeTransformResult<FirNamedReference> {
-        return transformNamedReference(resolvedCallableReference, data)
+        return transformElement(resolvedCallableReference, data)
     }
 
     open fun transformBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): CompositeTransformResult<FirNamedReference> {
-        return transformResolvedCallableReference(backingFieldReference, data)
+        return transformElement(backingFieldReference, data)
     }
 
     open fun transformDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): CompositeTransformResult<FirNamedReference> {
-        return transformResolvedCallableReference(delegateFieldReference, data)
+        return transformElement(delegateFieldReference, data)
     }
 
     open fun <E : FirReference> transformSuperReference(superReference: E, data: D): CompositeTransformResult<E> {
-        return transformReference(superReference, data)
+        return transformElement(superReference, data)
     }
 
     open fun <E : FirReference> transformThisReference(thisReference: E, data: D): CompositeTransformResult<E> {
-        return transformReference(thisReference, data)
+        return transformElement(thisReference, data)
     }
 
     open fun transformStatement(statement: FirStatement, data: D): CompositeTransformResult<FirStatement> {
@@ -186,223 +186,223 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
     }
 
     open fun transformAnnotatedStatement(annotatedStatement: FirAnnotatedStatement, data: D): CompositeTransformResult<FirStatement> {
-        return transformStatement(annotatedStatement, data)
+        return transformElement(annotatedStatement, data)
     }
 
     open fun transformExpression(expression: FirExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformAnnotatedStatement(expression, data)
+        return transformElement(expression, data)
     }
 
     open fun transformCall(call: FirCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(call, data)
+        return transformElement(call, data)
     }
 
     open fun transformArraySetCall(arraySetCall: FirArraySetCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCall(arraySetCall, data)
+        return transformElement(arraySetCall, data)
     }
 
     open fun transformCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList, data: D): CompositeTransformResult<FirStatement> {
-        return transformCall(callWithArgumentList, data)
+        return transformElement(callWithArgumentList, data)
     }
 
     open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCallWithArgumentList(annotationCall, data)
+        return transformElement(annotationCall, data)
     }
 
     open fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCallWithArgumentList(delegatedConstructorCall, data)
+        return transformElement(delegatedConstructorCall, data)
     }
 
     open fun transformOperatorCall(operatorCall: FirOperatorCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCallWithArgumentList(operatorCall, data)
+        return transformElement(operatorCall, data)
     }
 
     open fun transformOperationBasedCall(operationBasedCall: FirOperationBasedCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformOperatorCall(operationBasedCall, data)
+        return transformElement(operationBasedCall, data)
     }
 
     open fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformOperationBasedCall(typeOperatorCall, data)
+        return transformElement(typeOperatorCall, data)
     }
 
     open fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCallWithArgumentList(stringConcatenationCall, data)
+        return transformElement(stringConcatenationCall, data)
     }
 
     open fun transformUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList, data: D): CompositeTransformResult<FirStatement> {
-        return transformCallWithArgumentList(unknownTypeCallWithArgumentList, data)
+        return transformElement(unknownTypeCallWithArgumentList, data)
     }
 
     open fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeCallWithArgumentList(arrayOfCall, data)
+        return transformElement(arrayOfCall, data)
     }
 
     open fun transformFunctionCall(functionCall: FirFunctionCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeCallWithArgumentList(functionCall, data)
+        return transformElement(functionCall, data)
     }
 
     open fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformFunctionCall(componentCall, data)
+        return transformElement(componentCall, data)
     }
 
     open fun transformGetClassCall(getClassCall: FirGetClassCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeCallWithArgumentList(getClassCall, data)
+        return transformElement(getClassCall, data)
     }
 
     open fun transformUncheckedNotNullCast(uncheckedNotNullCast: FirUncheckedNotNullCast, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeCallWithArgumentList(uncheckedNotNullCast, data)
+        return transformElement(uncheckedNotNullCast, data)
     }
 
     open fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(jump, data)
+        return transformElement(jump, data)
     }
 
     open fun transformLoopJump(loopJump: FirLoopJump, data: D): CompositeTransformResult<FirStatement> {
-        return transformJump(loopJump, data)
+        return transformElement(loopJump, data)
     }
 
     open fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformLoopJump(breakExpression, data)
+        return transformElement(breakExpression, data)
     }
 
     open fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformLoopJump(continueExpression, data)
+        return transformElement(continueExpression, data)
     }
 
     open fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformJump(returnExpression, data)
+        return transformElement(returnExpression, data)
     }
 
     open fun transformThrowExpression(throwExpression: FirThrowExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(throwExpression, data)
+        return transformElement(throwExpression, data)
     }
 
     open fun transformUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(unknownTypeExpression, data)
+        return transformElement(unknownTypeExpression, data)
     }
 
     open fun transformBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeExpression(binaryLogicExpression, data)
+        return transformElement(binaryLogicExpression, data)
     }
 
     open fun transformBlock(block: FirBlock, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeExpression(block, data)
+        return transformElement(block, data)
     }
 
     open fun transformCallLikeControlFlowExpression(callLikeControlFlowExpression: FirCallLikeControlFlowExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeExpression(callLikeControlFlowExpression, data)
+        return transformElement(callLikeControlFlowExpression, data)
     }
 
     open fun transformTryExpression(tryExpression: FirTryExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformCallLikeControlFlowExpression(tryExpression, data)
+        return transformElement(tryExpression, data)
     }
 
     open fun transformWhenExpression(whenExpression: FirWhenExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformCallLikeControlFlowExpression(whenExpression, data)
+        return transformElement(whenExpression, data)
     }
 
     open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeExpression(classReferenceExpression, data)
+        return transformElement(classReferenceExpression, data)
     }
 
     open fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeExpression(constExpression, data)
+        return transformElement(constExpression, data)
     }
 
     open fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeExpression(errorExpression, data)
+        return transformElement(errorExpression, data)
     }
 
     open fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeExpression(qualifiedAccessExpression, data)
+        return transformElement(qualifiedAccessExpression, data)
     }
 
     open fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): CompositeTransformResult<FirStatement> {
-        return transformQualifiedAccessExpression(callableReferenceAccess, data)
+        return transformElement(callableReferenceAccess, data)
     }
 
     open fun transformExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): CompositeTransformResult<FirStatement> {
-        return transformQualifiedAccessExpression(expressionWithSmartcast, data)
+        return transformElement(expressionWithSmartcast, data)
     }
 
     open fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeExpression(resolvedQualifier, data)
+        return transformElement(resolvedQualifier, data)
     }
 
     open fun transformWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformUnknownTypeExpression(whenSubjectExpression, data)
+        return transformElement(whenSubjectExpression, data)
     }
 
     open fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(wrappedExpression, data)
+        return transformElement(wrappedExpression, data)
     }
 
     open fun transformWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformWrappedExpression(wrappedArgumentExpression, data)
+        return transformElement(wrappedArgumentExpression, data)
     }
 
     open fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformWrappedArgumentExpression(lambdaArgumentExpression, data)
+        return transformElement(lambdaArgumentExpression, data)
     }
 
     open fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformWrappedArgumentExpression(namedArgumentExpression, data)
+        return transformElement(namedArgumentExpression, data)
     }
 
     open fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformWrappedArgumentExpression(spreadArgumentExpression, data)
+        return transformElement(spreadArgumentExpression, data)
     }
 
     open fun transformWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformWrappedExpression(wrappedDelegateExpression, data)
+        return transformElement(wrappedDelegateExpression, data)
     }
 
     open fun transformClass(klass: FirClass, data: D): CompositeTransformResult<FirStatement> {
-        return transformStatement(klass, data)
+        return transformElement(klass, data)
     }
 
     open fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: D): CompositeTransformResult<FirStatement> {
-        return transformClass(anonymousObject, data)
+        return transformElement(anonymousObject, data)
     }
 
     open fun transformModifiableClass(modifiableClass: FirModifiableClass, data: D): CompositeTransformResult<FirStatement> {
-        return transformClass(modifiableClass, data)
+        return transformElement(modifiableClass, data)
     }
 
     open fun transformErrorStatement(errorStatement: FirErrorStatement, data: D): CompositeTransformResult<FirStatement> {
-        return transformStatement(errorStatement, data)
+        return transformElement(errorStatement, data)
     }
 
     open fun transformLoop(loop: FirLoop, data: D): CompositeTransformResult<FirStatement> {
-        return transformStatement(loop, data)
+        return transformElement(loop, data)
     }
 
     open fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): CompositeTransformResult<FirStatement> {
-        return transformLoop(doWhileLoop, data)
+        return transformElement(doWhileLoop, data)
     }
 
     open fun transformWhileLoop(whileLoop: FirWhileLoop, data: D): CompositeTransformResult<FirStatement> {
-        return transformLoop(whileLoop, data)
+        return transformElement(whileLoop, data)
     }
 
     open fun transformResolvable(resolvable: FirResolvable, data: D): CompositeTransformResult<FirStatement> {
-        return transformStatement(resolvable, data)
+        return transformElement(resolvable, data)
     }
 
     open fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): CompositeTransformResult<FirStatement> {
-        return transformResolvable(qualifiedAccess, data)
+        return transformElement(qualifiedAccess, data)
     }
 
     open fun transformAssignment(assignment: FirAssignment, data: D): CompositeTransformResult<FirStatement> {
-        return transformQualifiedAccess(assignment, data)
+        return transformElement(assignment, data)
     }
 
     open fun transformVariableAssignment(variableAssignment: FirVariableAssignment, data: D): CompositeTransformResult<FirStatement> {
-        return transformAssignment(variableAssignment, data)
+        return transformElement(variableAssignment, data)
     }
 
     open fun <C : FirReference> transformModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess<C>, data: D): CompositeTransformResult<FirStatement> {
-        return transformQualifiedAccess(modifiableQualifiedAccess, data)
+        return transformElement(modifiableQualifiedAccess, data)
     }
 
     open fun <E : FirElement> transformTargetElement(targetElement: E, data: D): CompositeTransformResult<E> {
@@ -410,7 +410,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
     }
 
     open fun <E : FirTargetElement> transformLabeledElement(labeledElement: E, data: D): CompositeTransformResult<E> {
-        return transformTargetElement(labeledElement, data)
+        return transformElement(labeledElement, data)
     }
 
     open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult<FirTypeProjection> {
@@ -418,11 +418,11 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
     }
 
     open fun transformStarProjection(starProjection: FirStarProjection, data: D): CompositeTransformResult<FirTypeProjection> {
-        return transformTypeProjection(starProjection, data)
+        return transformElement(starProjection, data)
     }
 
     open fun transformTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): CompositeTransformResult<FirTypeProjection> {
-        return transformTypeProjection(typeProjectionWithVariance, data)
+        return transformElement(typeProjectionWithVariance, data)
     }
 
     open fun transformTypeRef(typeRef: FirTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
@@ -430,39 +430,39 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
     }
 
     open fun transformDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
-        return transformTypeRef(delegatedTypeRef, data)
+        return transformElement(delegatedTypeRef, data)
     }
 
     open fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
-        return transformTypeRef(implicitTypeRef, data)
+        return transformElement(implicitTypeRef, data)
     }
 
     open fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
-        return transformTypeRef(resolvedTypeRef, data)
+        return transformElement(resolvedTypeRef, data)
     }
 
     open fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
-        return transformResolvedTypeRef(errorTypeRef, data)
+        return transformElement(errorTypeRef, data)
     }
 
     open fun transformResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
-        return transformResolvedTypeRef(resolvedFunctionTypeRef, data)
+        return transformElement(resolvedFunctionTypeRef, data)
     }
 
     open fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult<FirTypeRef> {
-        return transformTypeRef(typeRefWithNullability, data)
+        return transformElement(typeRefWithNullability, data)
     }
 
     open fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
-        return transformTypeRefWithNullability(dynamicTypeRef, data)
+        return transformElement(dynamicTypeRef, data)
     }
 
     open fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
-        return transformTypeRefWithNullability(functionTypeRef, data)
+        return transformElement(functionTypeRef, data)
     }
 
     open fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
-        return transformTypeRefWithNullability(userTypeRef, data)
+        return transformElement(userTypeRef, data)
     }
 
     open fun transformWhenBranch(whenBranch: FirWhenBranch, data: D): CompositeTransformResult<FirWhenBranch> {

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt

@@ -26,99 +26,99 @@ abstract class FirVisitor<out R, in D> {
     }
 
     open fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: D): R {
-        return visitDeclaration(callableDeclaration, data)
+        return visitElement(callableDeclaration, data)
     }
 
     open fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: D): R {
-        return visitDeclaration(callableMemberDeclaration, data)
+        return visitElement(callableMemberDeclaration, data)
     }
 
     open fun visitDeclarationWithBody(declarationWithBody: FirDeclarationWithBody, data: D): R {
-        return visitDeclaration(declarationWithBody, data)
+        return visitElement(declarationWithBody, data)
     }
 
     open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): R {
-        return visitDeclarationWithBody(anonymousInitializer, data)
+        return visitElement(anonymousInitializer, data)
     }
 
     open fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>, data: D): R {
-        return visitDeclarationWithBody(function, data)
+        return visitElement(function, data)
     }
 
     open fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): R {
-        return visitFunction(anonymousFunction, data)
+        return visitElement(anonymousFunction, data)
     }
 
     open fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>, data: D): R {
-        return visitFunction(memberFunction, data)
+        return visitElement(memberFunction, data)
     }
 
     open fun visitConstructor(constructor: FirConstructor, data: D): R {
-        return visitMemberFunction(constructor, data)
+        return visitElement(constructor, data)
     }
 
     open fun visitNamedFunction(namedFunction: FirNamedFunction, data: D): R {
-        return visitMemberFunction(namedFunction, data)
+        return visitElement(namedFunction, data)
     }
 
     open fun <F : FirFunction<F>> visitModifiableFunction(modifiableFunction: FirModifiableFunction<F>, data: D): R {
-        return visitFunction(modifiableFunction, data)
+        return visitElement(modifiableFunction, data)
     }
 
     open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): R {
-        return visitFunction(propertyAccessor, data)
+        return visitElement(propertyAccessor, data)
     }
 
     open fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: D): R {
-        return visitDeclaration(errorDeclaration, data)
+        return visitElement(errorDeclaration, data)
     }
 
     open fun visitField(field: FirField, data: D): R {
-        return visitDeclaration(field, data)
+        return visitElement(field, data)
     }
 
     open fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration, data: D): R {
-        return visitDeclaration(namedDeclaration, data)
+        return visitElement(namedDeclaration, data)
     }
 
     open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): R {
-        return visitNamedDeclaration(memberDeclaration, data)
+        return visitElement(memberDeclaration, data)
     }
 
     open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): R {
-        return visitMemberDeclaration(classLikeDeclaration, data)
+        return visitElement(classLikeDeclaration, data)
     }
 
     open fun visitRegularClass(regularClass: FirRegularClass, data: D): R {
-        return visitClassLikeDeclaration(regularClass, data)
+        return visitElement(regularClass, data)
     }
 
     open fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): R {
-        return visitRegularClass(enumEntry, data)
+        return visitElement(enumEntry, data)
     }
 
     open fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): R {
-        return visitClassLikeDeclaration(typeAlias, data)
+        return visitElement(typeAlias, data)
     }
 
     open fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): R {
-        return visitNamedDeclaration(typeParameter, data)
+        return visitElement(typeParameter, data)
     }
 
     open fun visitProperty(property: FirProperty, data: D): R {
-        return visitDeclaration(property, data)
+        return visitElement(property, data)
     }
 
     open fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): R {
-        return visitDeclaration(typedDeclaration, data)
+        return visitElement(typedDeclaration, data)
     }
 
     open fun visitValueParameter(valueParameter: FirValueParameter, data: D): R {
-        return visitDeclaration(valueParameter, data)
+        return visitElement(valueParameter, data)
     }
 
     open fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>, data: D): R {
-        return visitDeclaration(variable, data)
+        return visitElement(variable, data)
     }
 
     open fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus, data: D): R {
@@ -126,7 +126,7 @@ abstract class FirVisitor<out R, in D> {
     }
 
     open fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): R {
-        return visitDeclarationStatus(resolvedDeclarationStatus, data)
+        return visitElement(resolvedDeclarationStatus, data)
     }
 
     open fun visitImport(import: FirImport, data: D): R {
@@ -134,7 +134,7 @@ abstract class FirVisitor<out R, in D> {
     }
 
     open fun visitResolvedImport(resolvedImport: FirResolvedImport, data: D): R {
-        return visitImport(resolvedImport, data)
+        return visitElement(resolvedImport, data)
     }
 
     open fun visitLabel(label: FirLabel, data: D): R {
@@ -146,7 +146,7 @@ abstract class FirVisitor<out R, in D> {
     }
 
     open fun visitFile(file: FirFile, data: D): R {
-        return visitPackageFragment(file, data)
+        return visitElement(file, data)
     }
 
     open fun visitReference(reference: FirReference, data: D): R {
@@ -154,31 +154,31 @@ abstract class FirVisitor<out R, in D> {
     }
 
     open fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: D): R {
-        return visitReference(controlFlowGraphReference, data)
+        return visitElement(controlFlowGraphReference, data)
     }
 
     open fun visitNamedReference(namedReference: FirNamedReference, data: D): R {
-        return visitReference(namedReference, data)
+        return visitElement(namedReference, data)
     }
 
     open fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: D): R {
-        return visitNamedReference(resolvedCallableReference, data)
+        return visitElement(resolvedCallableReference, data)
     }
 
     open fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: D): R {
-        return visitResolvedCallableReference(backingFieldReference, data)
+        return visitElement(backingFieldReference, data)
     }
 
     open fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): R {
-        return visitResolvedCallableReference(delegateFieldReference, data)
+        return visitElement(delegateFieldReference, data)
     }
 
     open fun visitSuperReference(superReference: FirSuperReference, data: D): R {
-        return visitReference(superReference, data)
+        return visitElement(superReference, data)
     }
 
     open fun visitThisReference(thisReference: FirThisReference, data: D): R {
-        return visitReference(thisReference, data)
+        return visitElement(thisReference, data)
     }
 
     open fun visitStatement(statement: FirStatement, data: D): R {
@@ -186,223 +186,223 @@ abstract class FirVisitor<out R, in D> {
     }
 
     open fun visitAnnotatedStatement(annotatedStatement: FirAnnotatedStatement, data: D): R {
-        return visitStatement(annotatedStatement, data)
+        return visitElement(annotatedStatement, data)
     }
 
     open fun visitExpression(expression: FirExpression, data: D): R {
-        return visitAnnotatedStatement(expression, data)
+        return visitElement(expression, data)
     }
 
     open fun visitCall(call: FirCall, data: D): R {
-        return visitExpression(call, data)
+        return visitElement(call, data)
     }
 
     open fun visitArraySetCall(arraySetCall: FirArraySetCall, data: D): R {
-        return visitCall(arraySetCall, data)
+        return visitElement(arraySetCall, data)
     }
 
     open fun visitCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList, data: D): R {
-        return visitCall(callWithArgumentList, data)
+        return visitElement(callWithArgumentList, data)
     }
 
     open fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): R {
-        return visitCallWithArgumentList(annotationCall, data)
+        return visitElement(annotationCall, data)
     }
 
     open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): R {
-        return visitCallWithArgumentList(delegatedConstructorCall, data)
+        return visitElement(delegatedConstructorCall, data)
     }
 
     open fun visitOperatorCall(operatorCall: FirOperatorCall, data: D): R {
-        return visitCallWithArgumentList(operatorCall, data)
+        return visitElement(operatorCall, data)
     }
 
     open fun visitOperationBasedCall(operationBasedCall: FirOperationBasedCall, data: D): R {
-        return visitOperatorCall(operationBasedCall, data)
+        return visitElement(operationBasedCall, data)
     }
 
     open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): R {
-        return visitOperationBasedCall(typeOperatorCall, data)
+        return visitElement(typeOperatorCall, data)
     }
 
     open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): R {
-        return visitCallWithArgumentList(stringConcatenationCall, data)
+        return visitElement(stringConcatenationCall, data)
     }
 
     open fun visitUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList, data: D): R {
-        return visitCallWithArgumentList(unknownTypeCallWithArgumentList, data)
+        return visitElement(unknownTypeCallWithArgumentList, data)
     }
 
     open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): R {
-        return visitUnknownTypeCallWithArgumentList(arrayOfCall, data)
+        return visitElement(arrayOfCall, data)
     }
 
     open fun visitFunctionCall(functionCall: FirFunctionCall, data: D): R {
-        return visitUnknownTypeCallWithArgumentList(functionCall, data)
+        return visitElement(functionCall, data)
     }
 
     open fun visitComponentCall(componentCall: FirComponentCall, data: D): R {
-        return visitFunctionCall(componentCall, data)
+        return visitElement(componentCall, data)
     }
 
     open fun visitGetClassCall(getClassCall: FirGetClassCall, data: D): R {
-        return visitUnknownTypeCallWithArgumentList(getClassCall, data)
+        return visitElement(getClassCall, data)
     }
 
     open fun visitUncheckedNotNullCast(uncheckedNotNullCast: FirUncheckedNotNullCast, data: D): R {
-        return visitUnknownTypeCallWithArgumentList(uncheckedNotNullCast, data)
+        return visitElement(uncheckedNotNullCast, data)
     }
 
     open fun <E : FirTargetElement> visitJump(jump: FirJump<E>, data: D): R {
-        return visitExpression(jump, data)
+        return visitElement(jump, data)
     }
 
     open fun visitLoopJump(loopJump: FirLoopJump, data: D): R {
-        return visitJump(loopJump, data)
+        return visitElement(loopJump, data)
     }
 
     open fun visitBreakExpression(breakExpression: FirBreakExpression, data: D): R {
-        return visitLoopJump(breakExpression, data)
+        return visitElement(breakExpression, data)
     }
 
     open fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): R {
-        return visitLoopJump(continueExpression, data)
+        return visitElement(continueExpression, data)
     }
 
     open fun visitReturnExpression(returnExpression: FirReturnExpression, data: D): R {
-        return visitJump(returnExpression, data)
+        return visitElement(returnExpression, data)
     }
 
     open fun visitThrowExpression(throwExpression: FirThrowExpression, data: D): R {
-        return visitExpression(throwExpression, data)
+        return visitElement(throwExpression, data)
     }
 
     open fun visitUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression, data: D): R {
-        return visitExpression(unknownTypeExpression, data)
+        return visitElement(unknownTypeExpression, data)
     }
 
     open fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: D): R {
-        return visitUnknownTypeExpression(binaryLogicExpression, data)
+        return visitElement(binaryLogicExpression, data)
     }
 
     open fun visitBlock(block: FirBlock, data: D): R {
-        return visitUnknownTypeExpression(block, data)
+        return visitElement(block, data)
     }
 
     open fun visitCallLikeControlFlowExpression(callLikeControlFlowExpression: FirCallLikeControlFlowExpression, data: D): R {
-        return visitUnknownTypeExpression(callLikeControlFlowExpression, data)
+        return visitElement(callLikeControlFlowExpression, data)
     }
 
     open fun visitTryExpression(tryExpression: FirTryExpression, data: D): R {
-        return visitCallLikeControlFlowExpression(tryExpression, data)
+        return visitElement(tryExpression, data)
     }
 
     open fun visitWhenExpression(whenExpression: FirWhenExpression, data: D): R {
-        return visitCallLikeControlFlowExpression(whenExpression, data)
+        return visitElement(whenExpression, data)
     }
 
     open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): R {
-        return visitUnknownTypeExpression(classReferenceExpression, data)
+        return visitElement(classReferenceExpression, data)
     }
 
     open fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: D): R {
-        return visitUnknownTypeExpression(constExpression, data)
+        return visitElement(constExpression, data)
     }
 
     open fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): R {
-        return visitUnknownTypeExpression(errorExpression, data)
+        return visitElement(errorExpression, data)
     }
 
     open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): R {
-        return visitUnknownTypeExpression(qualifiedAccessExpression, data)
+        return visitElement(qualifiedAccessExpression, data)
     }
 
     open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): R {
-        return visitQualifiedAccessExpression(callableReferenceAccess, data)
+        return visitElement(callableReferenceAccess, data)
     }
 
     open fun visitExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast, data: D): R {
-        return visitQualifiedAccessExpression(expressionWithSmartcast, data)
+        return visitElement(expressionWithSmartcast, data)
     }
 
     open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): R {
-        return visitUnknownTypeExpression(resolvedQualifier, data)
+        return visitElement(resolvedQualifier, data)
     }
 
     open fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): R {
-        return visitUnknownTypeExpression(whenSubjectExpression, data)
+        return visitElement(whenSubjectExpression, data)
     }
 
     open fun visitWrappedExpression(wrappedExpression: FirWrappedExpression, data: D): R {
-        return visitExpression(wrappedExpression, data)
+        return visitElement(wrappedExpression, data)
     }
 
     open fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): R {
-        return visitWrappedExpression(wrappedArgumentExpression, data)
+        return visitElement(wrappedArgumentExpression, data)
     }
 
     open fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): R {
-        return visitWrappedArgumentExpression(lambdaArgumentExpression, data)
+        return visitElement(lambdaArgumentExpression, data)
     }
 
     open fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): R {
-        return visitWrappedArgumentExpression(namedArgumentExpression, data)
+        return visitElement(namedArgumentExpression, data)
     }
 
     open fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): R {
-        return visitWrappedArgumentExpression(spreadArgumentExpression, data)
+        return visitElement(spreadArgumentExpression, data)
     }
 
     open fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: D): R {
-        return visitWrappedExpression(wrappedDelegateExpression, data)
+        return visitElement(wrappedDelegateExpression, data)
     }
 
     open fun visitClass(klass: FirClass, data: D): R {
-        return visitStatement(klass, data)
+        return visitElement(klass, data)
     }
 
     open fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: D): R {
-        return visitClass(anonymousObject, data)
+        return visitElement(anonymousObject, data)
     }
 
     open fun visitModifiableClass(modifiableClass: FirModifiableClass, data: D): R {
-        return visitClass(modifiableClass, data)
+        return visitElement(modifiableClass, data)
     }
 
     open fun visitErrorStatement(errorStatement: FirErrorStatement, data: D): R {
-        return visitStatement(errorStatement, data)
+        return visitElement(errorStatement, data)
     }
 
     open fun visitLoop(loop: FirLoop, data: D): R {
-        return visitStatement(loop, data)
+        return visitElement(loop, data)
     }
 
     open fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): R {
-        return visitLoop(doWhileLoop, data)
+        return visitElement(doWhileLoop, data)
     }
 
     open fun visitWhileLoop(whileLoop: FirWhileLoop, data: D): R {
-        return visitLoop(whileLoop, data)
+        return visitElement(whileLoop, data)
     }
 
     open fun visitResolvable(resolvable: FirResolvable, data: D): R {
-        return visitStatement(resolvable, data)
+        return visitElement(resolvable, data)
     }
 
     open fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): R {
-        return visitResolvable(qualifiedAccess, data)
+        return visitElement(qualifiedAccess, data)
     }
 
     open fun visitAssignment(assignment: FirAssignment, data: D): R {
-        return visitQualifiedAccess(assignment, data)
+        return visitElement(assignment, data)
     }
 
     open fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: D): R {
-        return visitAssignment(variableAssignment, data)
+        return visitElement(variableAssignment, data)
     }
 
     open fun <C : FirReference> visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess<C>, data: D): R {
-        return visitQualifiedAccess(modifiableQualifiedAccess, data)
+        return visitElement(modifiableQualifiedAccess, data)
     }
 
     open fun visitTargetElement(targetElement: FirTargetElement, data: D): R {
@@ -410,7 +410,7 @@ abstract class FirVisitor<out R, in D> {
     }
 
     open fun visitLabeledElement(labeledElement: FirLabeledElement, data: D): R {
-        return visitTargetElement(labeledElement, data)
+        return visitElement(labeledElement, data)
     }
 
     open fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): R {
@@ -418,11 +418,11 @@ abstract class FirVisitor<out R, in D> {
     }
 
     open fun visitStarProjection(starProjection: FirStarProjection, data: D): R {
-        return visitTypeProjection(starProjection, data)
+        return visitElement(starProjection, data)
     }
 
     open fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): R {
-        return visitTypeProjection(typeProjectionWithVariance, data)
+        return visitElement(typeProjectionWithVariance, data)
     }
 
     open fun visitTypeRef(typeRef: FirTypeRef, data: D): R {
@@ -430,39 +430,39 @@ abstract class FirVisitor<out R, in D> {
     }
 
     open fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: D): R {
-        return visitTypeRef(delegatedTypeRef, data)
+        return visitElement(delegatedTypeRef, data)
     }
 
     open fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): R {
-        return visitTypeRef(implicitTypeRef, data)
+        return visitElement(implicitTypeRef, data)
     }
 
     open fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): R {
-        return visitTypeRef(resolvedTypeRef, data)
+        return visitElement(resolvedTypeRef, data)
     }
 
     open fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): R {
-        return visitResolvedTypeRef(errorTypeRef, data)
+        return visitElement(errorTypeRef, data)
     }
 
     open fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): R {
-        return visitResolvedTypeRef(resolvedFunctionTypeRef, data)
+        return visitElement(resolvedFunctionTypeRef, data)
     }
 
     open fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): R {
-        return visitTypeRef(typeRefWithNullability, data)
+        return visitElement(typeRefWithNullability, data)
     }
 
     open fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): R {
-        return visitTypeRefWithNullability(dynamicTypeRef, data)
+        return visitElement(dynamicTypeRef, data)
     }
 
     open fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): R {
-        return visitTypeRefWithNullability(functionTypeRef, data)
+        return visitElement(functionTypeRef, data)
     }
 
     open fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: D): R {
-        return visitTypeRefWithNullability(userTypeRef, data)
+        return visitElement(userTypeRef, data)
     }
 
     open fun visitWhenBranch(whenBranch: FirWhenBranch, data: D): R {

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt

@@ -26,99 +26,99 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
     }
 
     open fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>) {
-        visitDeclaration(callableDeclaration, null)
+        visitElement(callableDeclaration, null)
     }
 
     open fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>) {
-        visitDeclaration(callableMemberDeclaration, null)
+        visitElement(callableMemberDeclaration, null)
     }
 
     open fun visitDeclarationWithBody(declarationWithBody: FirDeclarationWithBody) {
-        visitDeclaration(declarationWithBody, null)
+        visitElement(declarationWithBody, null)
     }
 
     open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer) {
-        visitDeclarationWithBody(anonymousInitializer, null)
+        visitElement(anonymousInitializer, null)
     }
 
     open fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>) {
-        visitDeclarationWithBody(function, null)
+        visitElement(function, null)
     }
 
     open fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) {
-        visitFunction(anonymousFunction, null)
+        visitElement(anonymousFunction, null)
     }
 
     open fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>) {
-        visitFunction(memberFunction, null)
+        visitElement(memberFunction, null)
     }
 
     open fun visitConstructor(constructor: FirConstructor) {
-        visitMemberFunction(constructor, null)
+        visitElement(constructor, null)
     }
 
     open fun visitNamedFunction(namedFunction: FirNamedFunction) {
-        visitMemberFunction(namedFunction, null)
+        visitElement(namedFunction, null)
     }
 
     open fun <F : FirFunction<F>> visitModifiableFunction(modifiableFunction: FirModifiableFunction<F>) {
-        visitFunction(modifiableFunction, null)
+        visitElement(modifiableFunction, null)
     }
 
     open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) {
-        visitFunction(propertyAccessor, null)
+        visitElement(propertyAccessor, null)
     }
 
     open fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration) {
-        visitDeclaration(errorDeclaration, null)
+        visitElement(errorDeclaration, null)
     }
 
     open fun visitField(field: FirField) {
-        visitDeclaration(field, null)
+        visitElement(field, null)
     }
 
     open fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration) {
-        visitDeclaration(namedDeclaration, null)
+        visitElement(namedDeclaration, null)
     }
 
     open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) {
-        visitNamedDeclaration(memberDeclaration, null)
+        visitElement(memberDeclaration, null)
     }
 
     open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>) {
-        visitMemberDeclaration(classLikeDeclaration, null)
+        visitElement(classLikeDeclaration, null)
     }
 
     open fun visitRegularClass(regularClass: FirRegularClass) {
-        visitClassLikeDeclaration(regularClass, null)
+        visitElement(regularClass, null)
     }
 
     open fun visitEnumEntry(enumEntry: FirEnumEntry) {
-        visitRegularClass(enumEntry, null)
+        visitElement(enumEntry, null)
     }
 
     open fun visitTypeAlias(typeAlias: FirTypeAlias) {
-        visitClassLikeDeclaration(typeAlias, null)
+        visitElement(typeAlias, null)
     }
 
     open fun visitTypeParameter(typeParameter: FirTypeParameter) {
-        visitNamedDeclaration(typeParameter, null)
+        visitElement(typeParameter, null)
     }
 
     open fun visitProperty(property: FirProperty) {
-        visitDeclaration(property, null)
+        visitElement(property, null)
     }
 
     open fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration) {
-        visitDeclaration(typedDeclaration, null)
+        visitElement(typedDeclaration, null)
     }
 
     open fun visitValueParameter(valueParameter: FirValueParameter) {
-        visitDeclaration(valueParameter, null)
+        visitElement(valueParameter, null)
     }
 
     open fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>) {
-        visitDeclaration(variable, null)
+        visitElement(variable, null)
     }
 
     open fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus) {
@@ -126,7 +126,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
     }
 
     open fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus) {
-        visitDeclarationStatus(resolvedDeclarationStatus, null)
+        visitElement(resolvedDeclarationStatus, null)
     }
 
     open fun visitImport(import: FirImport) {
@@ -134,7 +134,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
     }
 
     open fun visitResolvedImport(resolvedImport: FirResolvedImport) {
-        visitImport(resolvedImport, null)
+        visitElement(resolvedImport, null)
     }
 
     open fun visitLabel(label: FirLabel) {
@@ -146,7 +146,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
     }
 
     open fun visitFile(file: FirFile) {
-        visitPackageFragment(file, null)
+        visitElement(file, null)
     }
 
     open fun visitReference(reference: FirReference) {
@@ -154,31 +154,31 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
     }
 
     open fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) {
-        visitReference(controlFlowGraphReference, null)
+        visitElement(controlFlowGraphReference, null)
     }
 
     open fun visitNamedReference(namedReference: FirNamedReference) {
-        visitReference(namedReference, null)
+        visitElement(namedReference, null)
     }
 
     open fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) {
-        visitNamedReference(resolvedCallableReference, null)
+        visitElement(resolvedCallableReference, null)
     }
 
     open fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference) {
-        visitResolvedCallableReference(backingFieldReference, null)
+        visitElement(backingFieldReference, null)
     }
 
     open fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference) {
-        visitResolvedCallableReference(delegateFieldReference, null)
+        visitElement(delegateFieldReference, null)
     }
 
     open fun visitSuperReference(superReference: FirSuperReference) {
-        visitReference(superReference, null)
+        visitElement(superReference, null)
     }
 
     open fun visitThisReference(thisReference: FirThisReference) {
-        visitReference(thisReference, null)
+        visitElement(thisReference, null)
     }
 
     open fun visitStatement(statement: FirStatement) {
@@ -186,223 +186,223 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
     }
 
     open fun visitAnnotatedStatement(annotatedStatement: FirAnnotatedStatement) {
-        visitStatement(annotatedStatement, null)
+        visitElement(annotatedStatement, null)
     }
 
     open fun visitExpression(expression: FirExpression) {
-        visitAnnotatedStatement(expression, null)
+        visitElement(expression, null)
     }
 
     open fun visitCall(call: FirCall) {
-        visitExpression(call, null)
+        visitElement(call, null)
     }
 
     open fun visitArraySetCall(arraySetCall: FirArraySetCall) {
-        visitCall(arraySetCall, null)
+        visitElement(arraySetCall, null)
     }
 
     open fun visitCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList) {
-        visitCall(callWithArgumentList, null)
+        visitElement(callWithArgumentList, null)
     }
 
     open fun visitAnnotationCall(annotationCall: FirAnnotationCall) {
-        visitCallWithArgumentList(annotationCall, null)
+        visitElement(annotationCall, null)
     }
 
     open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) {
-        visitCallWithArgumentList(delegatedConstructorCall, null)
+        visitElement(delegatedConstructorCall, null)
     }
 
     open fun visitOperatorCall(operatorCall: FirOperatorCall) {
-        visitCallWithArgumentList(operatorCall, null)
+        visitElement(operatorCall, null)
     }
 
     open fun visitOperationBasedCall(operationBasedCall: FirOperationBasedCall) {
-        visitOperatorCall(operationBasedCall, null)
+        visitElement(operationBasedCall, null)
     }
 
     open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) {
-        visitOperationBasedCall(typeOperatorCall, null)
+        visitElement(typeOperatorCall, null)
     }
 
     open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall) {
-        visitCallWithArgumentList(stringConcatenationCall, null)
+        visitElement(stringConcatenationCall, null)
     }
 
     open fun visitUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList) {
-        visitCallWithArgumentList(unknownTypeCallWithArgumentList, null)
+        visitElement(unknownTypeCallWithArgumentList, null)
     }
 
     open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall) {
-        visitUnknownTypeCallWithArgumentList(arrayOfCall, null)
+        visitElement(arrayOfCall, null)
     }
 
     open fun visitFunctionCall(functionCall: FirFunctionCall) {
-        visitUnknownTypeCallWithArgumentList(functionCall, null)
+        visitElement(functionCall, null)
     }
 
     open fun visitComponentCall(componentCall: FirComponentCall) {
-        visitFunctionCall(componentCall, null)
+        visitElement(componentCall, null)
     }
 
     open fun visitGetClassCall(getClassCall: FirGetClassCall) {
-        visitUnknownTypeCallWithArgumentList(getClassCall, null)
+        visitElement(getClassCall, null)
     }
 
     open fun visitUncheckedNotNullCast(uncheckedNotNullCast: FirUncheckedNotNullCast) {
-        visitUnknownTypeCallWithArgumentList(uncheckedNotNullCast, null)
+        visitElement(uncheckedNotNullCast, null)
     }
 
     open fun <E : FirTargetElement> visitJump(jump: FirJump<E>) {
-        visitExpression(jump, null)
+        visitElement(jump, null)
     }
 
     open fun visitLoopJump(loopJump: FirLoopJump) {
-        visitJump(loopJump, null)
+        visitElement(loopJump, null)
     }
 
     open fun visitBreakExpression(breakExpression: FirBreakExpression) {
-        visitLoopJump(breakExpression, null)
+        visitElement(breakExpression, null)
     }
 
     open fun visitContinueExpression(continueExpression: FirContinueExpression) {
-        visitLoopJump(continueExpression, null)
+        visitElement(continueExpression, null)
     }
 
     open fun visitReturnExpression(returnExpression: FirReturnExpression) {
-        visitJump(returnExpression, null)
+        visitElement(returnExpression, null)
     }
 
     open fun visitThrowExpression(throwExpression: FirThrowExpression) {
-        visitExpression(throwExpression, null)
+        visitElement(throwExpression, null)
     }
 
     open fun visitUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression) {
-        visitExpression(unknownTypeExpression, null)
+        visitElement(unknownTypeExpression, null)
     }
 
     open fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression) {
-        visitUnknownTypeExpression(binaryLogicExpression, null)
+        visitElement(binaryLogicExpression, null)
     }
 
     open fun visitBlock(block: FirBlock) {
-        visitUnknownTypeExpression(block, null)
+        visitElement(block, null)
     }
 
     open fun visitCallLikeControlFlowExpression(callLikeControlFlowExpression: FirCallLikeControlFlowExpression) {
-        visitUnknownTypeExpression(callLikeControlFlowExpression, null)
+        visitElement(callLikeControlFlowExpression, null)
     }
 
     open fun visitTryExpression(tryExpression: FirTryExpression) {
-        visitCallLikeControlFlowExpression(tryExpression, null)
+        visitElement(tryExpression, null)
     }
 
     open fun visitWhenExpression(whenExpression: FirWhenExpression) {
-        visitCallLikeControlFlowExpression(whenExpression, null)
+        visitElement(whenExpression, null)
     }
 
     open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression) {
-        visitUnknownTypeExpression(classReferenceExpression, null)
+        visitElement(classReferenceExpression, null)
     }
 
     open fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
-        visitUnknownTypeExpression(constExpression, null)
+        visitElement(constExpression, null)
     }
 
     open fun visitErrorExpression(errorExpression: FirErrorExpression) {
-        visitUnknownTypeExpression(errorExpression, null)
+        visitElement(errorExpression, null)
     }
 
     open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) {
-        visitUnknownTypeExpression(qualifiedAccessExpression, null)
+        visitElement(qualifiedAccessExpression, null)
     }
 
     open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
-        visitQualifiedAccessExpression(callableReferenceAccess, null)
+        visitElement(callableReferenceAccess, null)
     }
 
     open fun visitExpressionWithSmartcast(expressionWithSmartcast: FirExpressionWithSmartcast) {
-        visitQualifiedAccessExpression(expressionWithSmartcast, null)
+        visitElement(expressionWithSmartcast, null)
     }
 
     open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier) {
-        visitUnknownTypeExpression(resolvedQualifier, null)
+        visitElement(resolvedQualifier, null)
     }
 
     open fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression) {
-        visitUnknownTypeExpression(whenSubjectExpression, null)
+        visitElement(whenSubjectExpression, null)
     }
 
     open fun visitWrappedExpression(wrappedExpression: FirWrappedExpression) {
-        visitExpression(wrappedExpression, null)
+        visitElement(wrappedExpression, null)
     }
 
     open fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression) {
-        visitWrappedExpression(wrappedArgumentExpression, null)
+        visitElement(wrappedArgumentExpression, null)
     }
 
     open fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression) {
-        visitWrappedArgumentExpression(lambdaArgumentExpression, null)
+        visitElement(lambdaArgumentExpression, null)
     }
 
     open fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) {
-        visitWrappedArgumentExpression(namedArgumentExpression, null)
+        visitElement(namedArgumentExpression, null)
     }
 
     open fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression) {
-        visitWrappedArgumentExpression(spreadArgumentExpression, null)
+        visitElement(spreadArgumentExpression, null)
     }
 
     open fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression) {
-        visitWrappedExpression(wrappedDelegateExpression, null)
+        visitElement(wrappedDelegateExpression, null)
     }
 
     open fun visitClass(klass: FirClass) {
-        visitStatement(klass, null)
+        visitElement(klass, null)
     }
 
     open fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
-        visitClass(anonymousObject, null)
+        visitElement(anonymousObject, null)
     }
 
     open fun visitModifiableClass(modifiableClass: FirModifiableClass) {
-        visitClass(modifiableClass, null)
+        visitElement(modifiableClass, null)
     }
 
     open fun visitErrorStatement(errorStatement: FirErrorStatement) {
-        visitStatement(errorStatement, null)
+        visitElement(errorStatement, null)
     }
 
     open fun visitLoop(loop: FirLoop) {
-        visitStatement(loop, null)
+        visitElement(loop, null)
     }
 
     open fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop) {
-        visitLoop(doWhileLoop, null)
+        visitElement(doWhileLoop, null)
     }
 
     open fun visitWhileLoop(whileLoop: FirWhileLoop) {
-        visitLoop(whileLoop, null)
+        visitElement(whileLoop, null)
     }
 
     open fun visitResolvable(resolvable: FirResolvable) {
-        visitStatement(resolvable, null)
+        visitElement(resolvable, null)
     }
 
     open fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess) {
-        visitResolvable(qualifiedAccess, null)
+        visitElement(qualifiedAccess, null)
     }
 
     open fun visitAssignment(assignment: FirAssignment) {
-        visitQualifiedAccess(assignment, null)
+        visitElement(assignment, null)
     }
 
     open fun visitVariableAssignment(variableAssignment: FirVariableAssignment) {
-        visitAssignment(variableAssignment, null)
+        visitElement(variableAssignment, null)
     }
 
     open fun <C : FirReference> visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess<C>) {
-        visitQualifiedAccess(modifiableQualifiedAccess, null)
+        visitElement(modifiableQualifiedAccess, null)
     }
 
     open fun visitTargetElement(targetElement: FirTargetElement) {
@@ -410,7 +410,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
     }
 
     open fun visitLabeledElement(labeledElement: FirLabeledElement) {
-        visitTargetElement(labeledElement, null)
+        visitElement(labeledElement, null)
     }
 
     open fun visitTypeProjection(typeProjection: FirTypeProjection) {
@@ -418,11 +418,11 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
     }
 
     open fun visitStarProjection(starProjection: FirStarProjection) {
-        visitTypeProjection(starProjection, null)
+        visitElement(starProjection, null)
     }
 
     open fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance) {
-        visitTypeProjection(typeProjectionWithVariance, null)
+        visitElement(typeProjectionWithVariance, null)
     }
 
     open fun visitTypeRef(typeRef: FirTypeRef) {
@@ -430,39 +430,39 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
     }
 
     open fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef) {
-        visitTypeRef(delegatedTypeRef, null)
+        visitElement(delegatedTypeRef, null)
     }
 
     open fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) {
-        visitTypeRef(implicitTypeRef, null)
+        visitElement(implicitTypeRef, null)
     }
 
     open fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) {
-        visitTypeRef(resolvedTypeRef, null)
+        visitElement(resolvedTypeRef, null)
     }
 
     open fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {
-        visitResolvedTypeRef(errorTypeRef, null)
+        visitElement(errorTypeRef, null)
     }
 
     open fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef) {
-        visitResolvedTypeRef(resolvedFunctionTypeRef, null)
+        visitElement(resolvedFunctionTypeRef, null)
     }
 
     open fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) {
-        visitTypeRef(typeRefWithNullability, null)
+        visitElement(typeRefWithNullability, null)
     }
 
     open fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) {
-        visitTypeRefWithNullability(dynamicTypeRef, null)
+        visitElement(dynamicTypeRef, null)
     }
 
     open fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) {
-        visitTypeRefWithNullability(functionTypeRef, null)
+        visitElement(functionTypeRef, null)
     }
 
     open fun visitUserTypeRef(userTypeRef: FirUserTypeRef) {
-        visitTypeRefWithNullability(userTypeRef, null)
+        visitElement(userTypeRef, null)
     }
 
     open fun visitWhenBranch(whenBranch: FirWhenBranch) {

compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt

@@ -361,7 +361,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() {
                 data.append("[ERROR : ${namedReference.errorReason}]")
                 return
             }
-            super.visitNamedReference(namedReference, data)
+            visitElement(namedReference, data)
         }
 
         override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: StringBuilder) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt

@@ -6,10 +6,9 @@
 package org.jetbrains.kotlin.idea.fir
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.FirReference
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.*
@@ -173,6 +172,20 @@ fun KtElement.getOrBuildFir(
 
             override fun visitReference(reference: FirReference) {}
 
+            override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) {}
+
+            override fun visitNamedReference(namedReference: FirNamedReference) {}
+
+            override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) {}
+
+            override fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference) {}
+
+            override fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference) {}
+
+            override fun visitSuperReference(superReference: FirSuperReference) {}
+
+            override fun visitThisReference(thisReference: FirThisReference) {}
+
             override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {}
         })
         var current: PsiElement? = psi