diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/BaseTransformedType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/BaseTransformedType.kt new file mode 100644 index 00000000000..b4d7cb7ca8d --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/BaseTransformedType.kt @@ -0,0 +1,8 @@ +/* + * Copyright 2000-2018 JetBrains s.r.o. 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 + +annotation class BaseTransformedType \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt index b95a6117490..561ac710557 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt @@ -6,6 +6,8 @@ package org.jetbrains.kotlin.fir import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult +import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid @@ -24,4 +26,7 @@ interface FirElement { fun acceptChildren(visitor: FirVisitorVoid) = acceptChildren(visitor, null) + + fun transform(visitor: FirTransformer, data: D): CompositeTransformResult = + accept(visitor, data) as CompositeTransformResult } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt index 2c8d6d0db00..ac075dd988f 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt @@ -5,9 +5,11 @@ package org.jetbrains.kotlin.fir.declarations +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.visitors.FirVisitor +@BaseTransformedType interface FirDeclaration : FirElement { override fun accept(visitor: FirVisitor, data: D): R = diff --git a/compiler/fir/tree/visitors-generator/src/AbstractVisitorGenerator.kt b/compiler/fir/tree/visitors-generator/src/AbstractVisitorGenerator.kt index 3029d5fe7e9..45cafa3e48c 100644 --- a/compiler/fir/tree/visitors-generator/src/AbstractVisitorGenerator.kt +++ b/compiler/fir/tree/visitors-generator/src/AbstractVisitorGenerator.kt @@ -14,6 +14,7 @@ abstract class AbstractVisitorGenerator(val referencesData: DataCollector.Refere returnType: String, override: Boolean = false, final: Boolean = false, + typeParameters: List = emptyList(), body: (Printer.() -> Unit)? ) { @@ -31,7 +32,13 @@ abstract class AbstractVisitorGenerator(val referencesData: DataCollector.Refere printWithNoIndent("override ") } } - printWithNoIndent("fun ", name, "(") + printWithNoIndent("fun ") + if (typeParameters.isNotEmpty()) { + printWithNoIndent("<") + separatedOneLine(typeParameters, ", ") + printWithNoIndent("> ") + } + printWithNoIndent(name, "(") parameters .flatMap { (a, b) -> listOf(a, ": ", b, ", ") @@ -109,6 +116,12 @@ abstract class AbstractVisitorGenerator(val referencesData: DataCollector.Refere return builder.toString() } + + fun allElementTypes() = + referencesData.back.let { + it.keys + it.values.flatten() + }.distinct() + abstract fun Printer.generateContent() } \ No newline at end of file diff --git a/compiler/fir/tree/visitors-generator/src/DataCollector.kt b/compiler/fir/tree/visitors-generator/src/DataCollector.kt index c5a6acd51d9..8116d05a64b 100644 --- a/compiler/fir/tree/visitors-generator/src/DataCollector.kt +++ b/compiler/fir/tree/visitors-generator/src/DataCollector.kt @@ -13,6 +13,7 @@ class DataCollector { private val references = mutableMapOf>() private val packagePerClass = mutableMapOf() + private val baseTransformedTypes = mutableListOf() fun readFile(file: KtFile) { file.acceptChildren(object : KtVisitorVoid() { @@ -26,6 +27,12 @@ class DataCollector { val className = klass.name if (klass.isInterface() && className != null) { packagePerClass[className] = file.packageFqName + val isBaseTT = klass.annotationEntries.any { + it.shortName?.asString() == BASE_TRANSFORMED_TYPE_ANNOTATION_NAME + } + if (isBaseTT) { + baseTransformedTypes += className + } val manual = klass.superTypeListEntries.find { it.typeReference?.findDescendantOfType { annotationEntry -> @@ -75,9 +82,15 @@ class DataCollector { return ReferencesData( cleanBack.computeBackReferences().sorted(), cleanBack.sorted(), - packagePerClass.filterKeys { it in keysToKeep }.values.distinct().sortedBy { it.asString() } + packagePerClass.filterKeys { it in keysToKeep }.values.distinct().sortedBy { it.asString() }, + baseTransformedTypes.sorted() ) } - data class ReferencesData(val direct: Map>, val back: Map>, val usedPackages: List) + data class ReferencesData( + val direct: Map>, + val back: Map>, + val usedPackages: List, + val baseTransformedTypes: List + ) } \ No newline at end of file diff --git a/compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt b/compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt new file mode 100644 index 00000000000..182d6df5ebe --- /dev/null +++ b/compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt @@ -0,0 +1,108 @@ +/* + * Copyright 2000-2018 JetBrains s.r.o. 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.generator + +import org.jetbrains.kotlin.utils.Printer + +class ParametricTransformerGenerator(data: DataCollector.ReferencesData) : AbstractVisitorGenerator(data) { + override fun Printer.generateContent() { + println("abstract class $PARAMETRIC_TRANSFORMER_NAME : $SIMPLE_VISITOR_NAME<$TRANSFORMER_RESULT_NAME<$FIR_ELEMENT_CLASS_NAME>, D>() {") + indented { + + generateFunction( + "transformElement", + mapOf( + "element" to "E", + "data" to "D" + ), + constructCompositeBoxType("E"), + typeParameters = listOf("E : $FIR_ELEMENT_CLASS_NAME"), + body = null + ) + + referencesData.walkHierarchyTopDown(FIR_ELEMENT_CLASS_NAME) { parent, className -> + generateTransformMethod(className, parent) + } + + allElementTypes().forEach { + generateTrampolineVisit(it) + } + + } + println("}") + } + + + fun constructCompositeBoxType(type: String): String { + return "$TRANSFORMER_RESULT_NAME<$type>" + } + + val baseTypes = mutableMapOf().also { + for (baseTransformedType in referencesData.baseTransformedTypes) { + it[baseTransformedType] = baseTransformedType + } + + data.walkHierarchyTopDown(FIR_ELEMENT_CLASS_NAME) { parent, element -> + it[element] = it[parent] ?: return@walkHierarchyTopDown + } + } + + fun Printer.generateTrampolineVisit(className: String) { + val shortcutName = className.classNameWithoutFir + val parameterName = shortcutName.decapitalize().safeName + generateFunction( + name = "visit$shortcutName", + parameters = mapOf( + parameterName to className, + "data" to "D" + ), + returnType = constructCompositeBoxType(FIR_ELEMENT_CLASS_NAME), + override = true, + final = true + ) { + print("return ") + generateCall("transform$shortcutName", listOf(parameterName, "data")) + println() + } + } + + fun Printer.generateTransformMethod(className: String, parent: String) { + val baseType = baseTypes[className] + + val shortcutName = className.classNameWithoutFir + val parameterName = shortcutName.decapitalize().safeName + if (baseType == null) { + generateFunction( + "transform$shortcutName", + mapOf( + parameterName to "E", + "data" to "D" + ), + constructCompositeBoxType("E"), + typeParameters = listOf("E : $parent") + ) { + print("return ") + generateCall("transform${parent.classNameWithoutFir}", listOf(parameterName, "data")) + printlnWithNoIndent() + } + } else { + generateFunction( + "transform$shortcutName", + mapOf( + parameterName to className, + "data" to "D" + ), + constructCompositeBoxType(baseType) + ) { + print("return ") + generateCall("transform${parent.classNameWithoutFir}", listOf(parameterName, "data")) + printlnWithNoIndent() + } + } + + } + +} \ No newline at end of file diff --git a/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt b/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt index d53265edae7..8e2b089e1bd 100644 --- a/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt +++ b/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt @@ -24,10 +24,7 @@ class UnitVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abstr generateVisit(klass, parent) } - val trampolines = referencesData.back.let { - it.keys + it.values.flatten() - }.distinct() - trampolines.forEach { + allElementTypes().forEach { generateTrampolineVisit(it) } diff --git a/compiler/fir/tree/visitors-generator/src/VisitorsGenerator.kt b/compiler/fir/tree/visitors-generator/src/VisitorsGenerator.kt index 9e51c52a0ad..e566b7cc186 100644 --- a/compiler/fir/tree/visitors-generator/src/VisitorsGenerator.kt +++ b/compiler/fir/tree/visitors-generator/src/VisitorsGenerator.kt @@ -18,6 +18,10 @@ const val FIR_ELEMENT_CLASS_NAME = "FirElement" const val VISITOR_PACKAGE = "org.jetbrains.kotlin.fir.visitors" const val SIMPLE_VISITOR_NAME = "FirVisitor" const val UNIT_VISITOR_NAME = "FirVisitorVoid" +const val PARAMETRIC_TRANSFORMER_NAME = "FirTransformer" +const val TRANSFORMER_RESULT_NAME = "CompositeTransformResult" + +const val BASE_TRANSFORMED_TYPE_ANNOTATION_NAME = "BaseTransformedType" const val VISITED_SUPERTYPE_ANNOTATION_NAME = "VisitedSupertype" const val WARNING_GENERATED_FILE = @@ -55,6 +59,7 @@ fun main(args: Array) { SimpleVisitorGenerator(data).runGenerator(packageDirectory.resolve("${SIMPLE_VISITOR_NAME}Generated.kt")) UnitVisitorGenerator(data).runGenerator(packageDirectory.resolve("${UNIT_VISITOR_NAME}Generated.kt")) + ParametricTransformerGenerator(data).runGenerator(packageDirectory.resolve("${PARAMETRIC_TRANSFORMER_NAME}Generated.kt")) } } diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt new file mode 100644 index 00000000000..c6000048ed5 --- /dev/null +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt @@ -0,0 +1,35 @@ +/* + * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.visitors + +import org.jetbrains.kotlin.fir.FirElement + +@Suppress("UNSUPPORTED_FEATURE") +inline class CompositeTransformResult(val a: Any) { + + companion object { + fun empty() = CompositeTransformResult(emptyList()) + fun single(t: T) = CompositeTransformResult(t) + fun many(l: List) = CompositeTransformResult(l) + } + + + val isSingle get() = a !is List<*> + val isEmpty get() = a is List<*> && a.isEmpty() + + val single: T + get() { + assert(isSingle) + return a as T + } + + val list: List + get() { + return a as List + } +} + +inline fun T.compose() = CompositeTransformResult.single(this) \ No newline at end of file diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt new file mode 100644 index 00000000000..09f174e8378 --- /dev/null +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt @@ -0,0 +1,359 @@ +/* + * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ +package org.jetbrains.kotlin.fir.visitors + +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.types.* + + +/** This file generated by :compiler:fir:tree:generateVisitors. DO NOT MODIFY MANUALLY! */ +abstract class FirTransformer : FirVisitor, D>() { + abstract fun transformElement(element: E, data: D): CompositeTransformResult + + open fun transformDeclaration(declaration: FirDeclaration, data: D): CompositeTransformResult { + return transformElement(declaration, data) + } + + open fun transformCallableMember(callableMember: FirCallableMember, data: D): CompositeTransformResult { + return transformDeclaration(callableMember, data) + } + + open fun transformDeclarationWithBody(declarationWithBody: FirDeclarationWithBody, data: D): CompositeTransformResult { + return transformDeclaration(declarationWithBody, data) + } + + open fun transformAnonymousInitializer( + anonymousInitializer: FirAnonymousInitializer, + data: D + ): CompositeTransformResult { + return transformDeclarationWithBody(anonymousInitializer, data) + } + + open fun transformFunction(function: FirFunction, data: D): CompositeTransformResult { + return transformDeclarationWithBody(function, data) + } + + open fun transformConstructor(constructor: FirConstructor, data: D): CompositeTransformResult { + return transformFunction(constructor, data) + } + + open fun transformNamedFunction(namedFunction: FirNamedFunction, data: D): CompositeTransformResult { + return transformFunction(namedFunction, data) + } + + open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult { + return transformFunction(propertyAccessor, data) + } + + open fun transformErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: D): CompositeTransformResult { + return transformDeclaration(errorDeclaration, data) + } + + open fun transformNamedDeclaration(namedDeclaration: FirNamedDeclaration, data: D): CompositeTransformResult { + return transformDeclaration(namedDeclaration, data) + } + + open fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): CompositeTransformResult { + return transformNamedDeclaration(memberDeclaration, data) + } + + open fun transformClass(klass: FirClass, data: D): CompositeTransformResult { + return transformMemberDeclaration(klass, data) + } + + open fun transformEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult { + return transformClass(enumEntry, data) + } + + open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult { + return transformMemberDeclaration(typeAlias, data) + } + + open fun transformTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult { + return transformNamedDeclaration(typeParameter, data) + } + + open fun transformProperty(property: FirProperty, data: D): CompositeTransformResult { + return transformDeclaration(property, data) + } + + open fun transformTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): CompositeTransformResult { + return transformDeclaration(typedDeclaration, data) + } + + open fun transformValueParameter(valueParameter: FirValueParameter, data: D): CompositeTransformResult { + return transformDeclaration(valueParameter, data) + } + + open fun transformVariable(variable: FirVariable, data: D): CompositeTransformResult { + return transformDeclaration(variable, data) + } + + open fun transformImport(import: E, data: D): CompositeTransformResult { + return transformElement(import, data) + } + + open fun transformPackageFragment(packageFragment: E, data: D): CompositeTransformResult { + return transformElement(packageFragment, data) + } + + open fun transformFile(file: E, data: D): CompositeTransformResult { + return transformPackageFragment(file, data) + } + + open fun transformStatement(statement: E, data: D): CompositeTransformResult { + return transformElement(statement, data) + } + + open fun transformExpression(expression: E, data: D): CompositeTransformResult { + return transformStatement(expression, data) + } + + open fun transformBody(body: E, data: D): CompositeTransformResult { + return transformExpression(body, data) + } + + open fun transformCall(call: E, data: D): CompositeTransformResult { + return transformExpression(call, data) + } + + open fun transformAnnotationCall(annotationCall: E, data: D): CompositeTransformResult { + return transformCall(annotationCall, data) + } + + open fun transformConstructorCall(constructorCall: E, data: D): CompositeTransformResult { + return transformCall(constructorCall, data) + } + + open fun transformType(type: E, data: D): CompositeTransformResult { + return transformElement(type, data) + } + + open fun transformDelegatedType(delegatedType: E, data: D): CompositeTransformResult { + return transformType(delegatedType, data) + } + + open fun transformErrorType(errorType: E, data: D): CompositeTransformResult { + return transformType(errorType, data) + } + + open fun transformImplicitType(implicitType: E, data: D): CompositeTransformResult { + return transformType(implicitType, data) + } + + open fun transformTypeWithNullability(typeWithNullability: E, data: D): CompositeTransformResult { + return transformType(typeWithNullability, data) + } + + open fun transformDynamicType(dynamicType: E, data: D): CompositeTransformResult { + return transformTypeWithNullability(dynamicType, data) + } + + open fun transformFunctionType(functionType: E, data: D): CompositeTransformResult { + return transformTypeWithNullability(functionType, data) + } + + open fun transformResolvedType(resolvedType: E, data: D): CompositeTransformResult { + return transformTypeWithNullability(resolvedType, data) + } + + open fun transformUserType(userType: E, data: D): CompositeTransformResult { + return transformTypeWithNullability(userType, data) + } + + open fun transformTypeProjection(typeProjection: E, data: D): CompositeTransformResult { + return transformElement(typeProjection, data) + } + + open fun transformStarProjection(starProjection: E, data: D): CompositeTransformResult { + return transformTypeProjection(starProjection, data) + } + + open fun transformTypeProjectionWithVariance( + typeProjectionWithVariance: E, + data: D + ): CompositeTransformResult { + return transformTypeProjection(typeProjectionWithVariance, data) + } + + final override fun visitCall(call: FirCall, data: D): CompositeTransformResult { + return transformCall(call, data) + } + + final override fun visitClass(klass: FirClass, data: D): CompositeTransformResult { + return transformClass(klass, data) + } + + final override fun visitDeclaration(declaration: FirDeclaration, data: D): CompositeTransformResult { + return transformDeclaration(declaration, data) + } + + final override fun visitDeclarationWithBody( + declarationWithBody: FirDeclarationWithBody, + data: D + ): CompositeTransformResult { + return transformDeclarationWithBody(declarationWithBody, data) + } + + final override fun visitElement(element: FirElement, data: D): CompositeTransformResult { + return transformElement(element, data) + } + + final override fun visitExpression(expression: FirExpression, data: D): CompositeTransformResult { + return transformExpression(expression, data) + } + + final override fun visitFunction(function: FirFunction, data: D): CompositeTransformResult { + return transformFunction(function, data) + } + + final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): CompositeTransformResult { + return transformMemberDeclaration(memberDeclaration, data) + } + + final override fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration, data: D): CompositeTransformResult { + return transformNamedDeclaration(namedDeclaration, data) + } + + final override fun visitPackageFragment(packageFragment: FirPackageFragment, data: D): CompositeTransformResult { + return transformPackageFragment(packageFragment, data) + } + + final override fun visitStatement(statement: FirStatement, data: D): CompositeTransformResult { + return transformStatement(statement, data) + } + + final override fun visitType(type: FirType, data: D): CompositeTransformResult { + return transformType(type, data) + } + + final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult { + return transformTypeProjection(typeProjection, data) + } + + final override fun visitTypeWithNullability( + typeWithNullability: FirTypeWithNullability, + data: D + ): CompositeTransformResult { + return transformTypeWithNullability(typeWithNullability, data) + } + + final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult { + return transformAnnotationCall(annotationCall, data) + } + + final override fun visitConstructorCall(constructorCall: FirConstructorCall, data: D): CompositeTransformResult { + return transformConstructorCall(constructorCall, data) + } + + final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult { + return transformEnumEntry(enumEntry, data) + } + + final override fun visitCallableMember(callableMember: FirCallableMember, data: D): CompositeTransformResult { + return transformCallableMember(callableMember, data) + } + + final override fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: D): CompositeTransformResult { + return transformErrorDeclaration(errorDeclaration, data) + } + + final override fun visitProperty(property: FirProperty, data: D): CompositeTransformResult { + return transformProperty(property, data) + } + + final override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): CompositeTransformResult { + return transformTypedDeclaration(typedDeclaration, data) + } + + final override fun visitValueParameter(valueParameter: FirValueParameter, data: D): CompositeTransformResult { + return transformValueParameter(valueParameter, data) + } + + final override fun visitVariable(variable: FirVariable, data: D): CompositeTransformResult { + return transformVariable(variable, data) + } + + final override fun visitAnonymousInitializer( + anonymousInitializer: FirAnonymousInitializer, + data: D + ): CompositeTransformResult { + return transformAnonymousInitializer(anonymousInitializer, data) + } + + final override fun visitImport(import: FirImport, data: D): CompositeTransformResult { + return transformImport(import, data) + } + + final override fun visitBody(body: FirBody, data: D): CompositeTransformResult { + return transformBody(body, data) + } + + final override fun visitConstructor(constructor: FirConstructor, data: D): CompositeTransformResult { + return transformConstructor(constructor, data) + } + + final override fun visitNamedFunction(namedFunction: FirNamedFunction, data: D): CompositeTransformResult { + return transformNamedFunction(namedFunction, data) + } + + final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult { + return transformPropertyAccessor(propertyAccessor, data) + } + + final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult { + return transformTypeAlias(typeAlias, data) + } + + final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult { + return transformTypeParameter(typeParameter, data) + } + + final override fun visitFile(file: FirFile, data: D): CompositeTransformResult { + return transformFile(file, data) + } + + final override fun visitDelegatedType(delegatedType: FirDelegatedType, data: D): CompositeTransformResult { + return transformDelegatedType(delegatedType, data) + } + + final override fun visitErrorType(errorType: FirErrorType, data: D): CompositeTransformResult { + return transformErrorType(errorType, data) + } + + final override fun visitImplicitType(implicitType: FirImplicitType, data: D): CompositeTransformResult { + return transformImplicitType(implicitType, data) + } + + final override fun visitStarProjection(starProjection: FirStarProjection, data: D): CompositeTransformResult { + return transformStarProjection(starProjection, data) + } + + final override fun visitTypeProjectionWithVariance( + typeProjectionWithVariance: FirTypeProjectionWithVariance, + data: D + ): CompositeTransformResult { + return transformTypeProjectionWithVariance(typeProjectionWithVariance, data) + } + + final override fun visitDynamicType(dynamicType: FirDynamicType, data: D): CompositeTransformResult { + return transformDynamicType(dynamicType, data) + } + + final override fun visitFunctionType(functionType: FirFunctionType, data: D): CompositeTransformResult { + return transformFunctionType(functionType, data) + } + + final override fun visitResolvedType(resolvedType: FirResolvedType, data: D): CompositeTransformResult { + return transformResolvedType(resolvedType, data) + } + + final override fun visitUserType(userType: FirUserType, data: D): CompositeTransformResult { + return transformUserType(userType, data) + } + +}