[FIR] Add default visitors and transformers with useful part of visited hierarchy

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

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
@@ -60,7 +61,7 @@ class Fir2IrVisitor(
     private val sourceManager: PsiSourceManager,
     override val irBuiltIns: IrBuiltIns,
     private val fakeOverrideMode: FakeOverrideMode
-) : FirVisitor<IrElement, Any?>(), IrGeneratorContextInterface {
+) : FirDefaultVisitor<IrElement, Any?>(), IrGeneratorContextInterface {
     companion object {
         private val NEGATED_OPERATIONS: Set<FirOperation> = EnumSet.of(FirOperation.NOT_EQ, FirOperation.NOT_IDENTITY)
 
@@ -297,10 +298,6 @@ 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
@@ -665,18 +662,6 @@ 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
@@ -809,10 +794,6 @@ 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)
     }

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

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -59,7 +60,7 @@ class FirProviderImpl(val session: FirSession) : FirProvider() {
         val packageName = file.packageFqName
         state.fileMap.merge(packageName, listOf(file)) { a, b -> a + b }
 
-        file.acceptChildren(object : FirVisitorVoid() {
+        file.acceptChildren(object : FirDefaultVisitorVoid() {
             override fun visitElement(element: FirElement) {}
 
 
@@ -102,10 +103,6 @@ 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/FirAbstractPhaseTransformer.kt

@@ -12,11 +12,11 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
 
 abstract class FirAbstractPhaseTransformer<D>(
     protected val transformerPhase: FirResolvePhase
-) : FirTransformer<D>() {
+) : FirDefaultTransformer<D>() {
 
     abstract val session: FirSession
 

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

@@ -162,10 +162,6 @@ open class FirBodyResolveTransformer(
         return result
     }
 
-    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Any?): CompositeTransformResult<FirDeclaration> {
-        return transformRegularClass(enumEntry, data)
-    }
-
     override fun transformUncheckedNotNullCast(
         uncheckedNotNullCast: FirUncheckedNotNullCast,
         data: Any?
@@ -272,13 +268,6 @@ open class FirBodyResolveTransformer(
         }
     }
 
-    override fun transformCallableReferenceAccess(
-        callableReferenceAccess: FirCallableReferenceAccess,
-        data: Any?
-    ): CompositeTransformResult<FirStatement> {
-        return transformQualifiedAccessExpression(callableReferenceAccess, data)
-    }
-
     override fun transformVariableAssignment(
         variableAssignment: FirVariableAssignment,
         data: Any?
@@ -486,10 +475,6 @@ open class FirBodyResolveTransformer(
 
     }
 
-    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()
@@ -523,21 +508,6 @@ open class FirBodyResolveTransformer(
         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 transformExpression(throwExpression, data).also {
             dataFlowAnalyzer.exitThrowExceptionNode(it.single as FirThrowExpression)

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

@@ -57,13 +57,6 @@ class FirCallCompletionResultsWriterTransformer(
         ).compose()
     }
 
-    override fun transformCallableReferenceAccess(
-        callableReferenceAccess: FirCallableReferenceAccess,
-        data: Nothing?
-    ): CompositeTransformResult<FirStatement> {
-        return transformQualifiedAccessExpression(callableReferenceAccess, data)
-    }
-
     override fun transformVariableAssignment(
         variableAssignment: FirVariableAssignment,
         data: Nothing?
@@ -137,10 +130,6 @@ class FirCallCompletionResultsWriterTransformer(
 
     }
 
-    override fun transformComponentCall(componentCall: FirComponentCall, data: Nothing?): CompositeTransformResult<FirStatement> {
-        return transformFunctionCall(componentCall, data)
-    }
-
     override fun transformAnonymousFunction(
         anonymousFunction: FirAnonymousFunction,
         data: Nothing?

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

@@ -58,34 +58,4 @@ 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

@@ -162,8 +162,4 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer(phase = FirResolv
     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

@@ -129,10 +129,6 @@ 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

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

@@ -96,44 +96,6 @@ open class FirTypeResolveTransformer : FirAbstractTreeTransformerWithSuperTypes(
         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)
     }

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

@@ -1,60 +0,0 @@
-/*
- * 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

@@ -13,10 +13,11 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
+import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.compose
 
-internal object MapArguments : FirTransformer<Map<FirElement, FirElement>>() {
+internal object MapArguments : FirDefaultTransformer<Map<FirElement, FirElement>>() {
     override fun <E : FirElement> transformElement(element: E, data: Map<FirElement, FirElement>): CompositeTransformResult<E> {
         return ((data[element] ?: element) as E).compose()
     }
@@ -34,36 +35,23 @@ internal object MapArguments : FirTransformer<Map<FirElement, FirElement>>() {
     ): CompositeTransformResult<FirStatement> {
         return (wrappedArgumentExpression.transformChildren(this, data) as FirStatement).compose()
     }
-
-    override fun transformLambdaArgumentExpression(
-        lambdaArgumentExpression: FirLambdaArgumentExpression,
-        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>() {
+internal object StoreType : FirDefaultTransformer<FirTypeRef>() {
+    override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
+        return element.compose()
+    }
+
     override fun transformTypeRef(typeRef: FirTypeRef, data: FirTypeRef): CompositeTransformResult<FirTypeRef> {
         return data.compose()
     }
 }
 
-internal object TransformImplicitType : FirTypeTransformer<FirTypeRef>() {
+internal object TransformImplicitType : FirDefaultTransformer<FirTypeRef>() {
+    override fun <E : FirElement> transformElement(element: E, data: FirTypeRef): CompositeTransformResult<E> {
+        return element.compose()
+    }
+
     override fun transformImplicitTypeRef(
         implicitTypeRef: FirImplicitTypeRef,
         data: FirTypeRef
@@ -73,7 +61,11 @@ internal object TransformImplicitType : FirTypeTransformer<FirTypeRef>() {
 }
 
 
-internal object StoreNameReference : FirTypeTransformer<FirNamedReference>() {
+internal object StoreNameReference : FirDefaultTransformer<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/FirResolveBench.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.psi.KtFile
@@ -172,7 +173,7 @@ class FirResolveBench(val withProgress: Boolean) {
             val fileDocumentManager = FileDocumentManager.getInstance()
 
             firFiles.forEach {
-                it.accept(object : FirVisitorVoid() {
+                it.accept(object : FirDefaultVisitorVoid() {
 
                     fun reportProblem(problem: String, psi: PsiElement) {
                         val document = try {
@@ -202,10 +203,6 @@ class FirResolveBench(val withProgress: Boolean) {
                         visitElement(functionCall)
                     }
 
-                    override fun visitComponentCall(componentCall: FirComponentCall) {
-                        visitFunctionCall(componentCall)
-                    }
-
                     override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) {
                         val typeRef = qualifiedAccessExpression.typeRef
                         if (typeRef is FirResolvedTypeRef) {
@@ -218,10 +215,6 @@ class FirResolveBench(val withProgress: Boolean) {
                         visitElement(qualifiedAccessExpression)
                     }
 
-                    override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
-                        visitQualifiedAccessExpression(callableReferenceAccess)
-                    }
-
                     override fun visitTypeRef(typeRef: FirTypeRef) {
                         unresolvedTypes++
 
@@ -232,34 +225,6 @@ 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/visitors/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt

@@ -0,0 +1,89 @@
+/*
+ * 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.visitors
+
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.types.*
+
+abstract class FirDefaultTransformer<D> : FirTransformer<D>() {
+    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)
+    }
+
+    override fun transformCallableReferenceAccess(
+        callableReferenceAccess: FirCallableReferenceAccess,
+        data: D
+    ): CompositeTransformResult<FirStatement> {
+        return transformQualifiedAccessExpression(callableReferenceAccess, data)
+    }
+
+    override fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult<FirStatement> {
+        return transformFunctionCall(componentCall, data)
+    }
+
+    override fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult<FirStatement> {
+        return transformJump(returnExpression, data)
+    }
+
+    override fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult<FirStatement> {
+        return transformJump(continueExpression, data)
+    }
+
+    override fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult<FirStatement> {
+        return transformJump(breakExpression, data)
+    }
+
+    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult<FirDeclaration> {
+        return transformRegularClass(enumEntry, data)
+    }
+
+    override fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
+        return transformWrappedArgumentExpression(lambdaArgumentExpression, data)
+    }
+
+    override fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
+        return transformWrappedArgumentExpression(spreadArgumentExpression, data)
+    }
+
+    override fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
+        return transformWrappedArgumentExpression(namedArgumentExpression, data)
+    }
+}
+

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

@@ -0,0 +1,85 @@
+/*
+ * 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.visitors
+
+import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.types.*
+
+abstract class FirDefaultVisitor<R, D> : FirVisitor<R, D>() {
+    override fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef, data: D): R {
+        return visitTypeRef(delegatedTypeRef, data)
+    }
+
+    override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): R {
+        return visitTypeRef(implicitTypeRef, data)
+    }
+
+    override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): R {
+        return visitTypeRef(resolvedTypeRef, data)
+    }
+
+    override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): R {
+        return visitResolvedTypeRef(errorTypeRef, data)
+    }
+
+    override fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef, data: D): R {
+        return visitResolvedTypeRef(resolvedFunctionTypeRef, data)
+    }
+
+    override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): R {
+        return visitTypeRef(typeRefWithNullability, data)
+    }
+
+    override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): R {
+        return visitTypeRefWithNullability(dynamicTypeRef, data)
+    }
+
+    override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): R {
+        return visitTypeRefWithNullability(functionTypeRef, data)
+    }
+
+    override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: D): R {
+        return visitTypeRefWithNullability(userTypeRef, data)
+    }
+
+    override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): R {
+        return visitQualifiedAccessExpression(callableReferenceAccess, data)
+    }
+
+    override fun visitComponentCall(componentCall: FirComponentCall, data: D): R {
+        return visitFunctionCall(componentCall, data)
+    }
+
+    override fun visitReturnExpression(returnExpression: FirReturnExpression, data: D): R {
+        return visitJump(returnExpression, data)
+    }
+
+    override fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): R {
+        return visitJump(continueExpression, data)
+    }
+
+    override fun visitBreakExpression(breakExpression: FirBreakExpression, data: D): R {
+        return visitJump(breakExpression, data)
+    }
+
+    override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): R {
+        return visitRegularClass(enumEntry, data)
+    }
+
+    override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): R {
+        return visitWrappedArgumentExpression(lambdaArgumentExpression, data)
+    }
+
+    override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): R {
+        return visitWrappedArgumentExpression(spreadArgumentExpression, data)
+    }
+
+    override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): R {
+        return visitWrappedArgumentExpression(namedArgumentExpression, data)
+    }
+}
+

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

@@ -0,0 +1,84 @@
+/*
+ * 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.visitors
+
+import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.types.*
+
+abstract class FirDefaultVisitorVoid : FirVisitorVoid() {
+    override fun visitDelegatedTypeRef(delegatedTypeRef: FirDelegatedTypeRef) {
+        return visitTypeRef(delegatedTypeRef)
+    }
+
+    override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) {
+        return visitTypeRef(implicitTypeRef)
+    }
+
+    override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) {
+        return visitTypeRef(resolvedTypeRef)
+    }
+
+    override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {
+        return visitResolvedTypeRef(errorTypeRef)
+    }
+
+    override fun visitResolvedFunctionTypeRef(resolvedFunctionTypeRef: FirResolvedFunctionTypeRef) {
+        return visitResolvedTypeRef(resolvedFunctionTypeRef)
+    }
+
+    override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) {
+        return visitTypeRef(typeRefWithNullability)
+    }
+
+    override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) {
+        return visitTypeRefWithNullability(dynamicTypeRef)
+    }
+
+    override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) {
+        return visitTypeRefWithNullability(functionTypeRef)
+    }
+
+    override fun visitUserTypeRef(userTypeRef: FirUserTypeRef) {
+        return visitTypeRefWithNullability(userTypeRef)
+    }
+
+    override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
+        return visitQualifiedAccessExpression(callableReferenceAccess)
+    }
+
+    override fun visitComponentCall(componentCall: FirComponentCall) {
+        return visitFunctionCall(componentCall)
+    }
+
+    override fun visitReturnExpression(returnExpression: FirReturnExpression) {
+        return visitJump(returnExpression)
+    }
+
+    override fun visitContinueExpression(continueExpression: FirContinueExpression) {
+        return visitJump(continueExpression)
+    }
+
+    override fun visitBreakExpression(breakExpression: FirBreakExpression) {
+        return visitJump(breakExpression)
+    }
+
+    override fun visitEnumEntry(enumEntry: FirEnumEntry) {
+        return visitRegularClass(enumEntry)
+    }
+
+    override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression) {
+        return visitWrappedArgumentExpression(lambdaArgumentExpression)
+    }
+
+    override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression) {
+        return visitWrappedArgumentExpression(spreadArgumentExpression)
+    }
+
+    override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) {
+        return visitWrappedArgumentExpression(namedArgumentExpression)
+    }
+}