From aa97175d4018e1d6539f30e3212174877b1392d6 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Tue, 15 Jan 2019 13:14:32 +0300 Subject: [PATCH] FIR generator: support type parameters with bounds for interfaces This commits also reorders bridge visit functions --- .../src/AbstractVisitorGenerator.kt | 12 +- .../visitors-generator/src/DataCollector.kt | 56 ++++- .../src/ParametricTransformerGenerator.kt | 8 +- .../src/SimpleVisitorGenerator.kt | 13 +- .../src/UnitVisitorGenerator.kt | 8 +- .../fir/visitors/FirTransformerGenerated.kt | 216 +++++++++--------- .../fir/visitors/FirVisitorVoidGenerated.kt | 216 +++++++++--------- 7 files changed, 286 insertions(+), 243 deletions(-) diff --git a/compiler/fir/tree/visitors-generator/src/AbstractVisitorGenerator.kt b/compiler/fir/tree/visitors-generator/src/AbstractVisitorGenerator.kt index 6caeee8e4ac..5f5993d7344 100644 --- a/compiler/fir/tree/visitors-generator/src/AbstractVisitorGenerator.kt +++ b/compiler/fir/tree/visitors-generator/src/AbstractVisitorGenerator.kt @@ -14,7 +14,7 @@ abstract class AbstractVisitorGenerator(val referencesData: DataCollector.Refere returnType: String, override: Boolean = false, final: Boolean = false, - typeParameters: List = emptyList(), + typeParametersWithBounds: List = emptyList(), body: (Printer.() -> Unit)? ) { @@ -33,15 +33,15 @@ abstract class AbstractVisitorGenerator(val referencesData: DataCollector.Refere } } printWithNoIndent("fun ") - if (typeParameters.isNotEmpty()) { + if (typeParametersWithBounds.isNotEmpty()) { printWithNoIndent("<") - separatedOneLine(typeParameters, ", ") + separatedOneLine(typeParametersWithBounds, ", ") printWithNoIndent("> ") } printWithNoIndent(name, "(") parameters - .flatMap { (a, b) -> - listOf(a, ": ", b, ", ") + .flatMap { (parameterName, typeNameWithTypeParameters) -> + listOf(parameterName, ": ", typeNameWithTypeParameters.asStringWithoutBounds(), ", ") }.dropLast(1) .forEach { printWithNoIndent(it) @@ -118,7 +118,7 @@ abstract class AbstractVisitorGenerator(val referencesData: DataCollector.Refere fun allElementTypes() = - referencesData.back.let { map -> + referencesData.direct.let { map -> map.keys + map.values.flatten() }.distinct() diff --git a/compiler/fir/tree/visitors-generator/src/DataCollector.kt b/compiler/fir/tree/visitors-generator/src/DataCollector.kt index 66b41f8d070..1dd80995f7f 100644 --- a/compiler/fir/tree/visitors-generator/src/DataCollector.kt +++ b/compiler/fir/tree/visitors-generator/src/DataCollector.kt @@ -11,16 +11,56 @@ import org.jetbrains.kotlin.psi.psiUtil.findDescendantOfType class DataCollector { - data class NameWithTypeParameters(val name: String, val typeParameters: List) : Comparable { + class NameWithTypeParameters private constructor( + val name: String, + val typeParameters: List, + private val typeParameterBounds: Map + ) : Comparable { + override fun compareTo(other: NameWithTypeParameters): Int = name.compareTo(other.name) - constructor(name: String, typeParameterString: String) : - this(name, typeParameterString.drop(1).dropLast(1).split(" ", "\t", ",").filter { it.isNotEmpty() }) + private constructor(name: String, typeParameters: Pair, Map>) : + this(name, typeParameters.first, typeParameters.second) - constructor(name: String) : this(name, emptyList()) + constructor(name: String, typeParameterString: String) : + this(name, typeParameterString.splitToParametersAndBounds()) + + constructor(name: String) : this(name, emptyList(), emptyMap()) + + fun typeParametersWithBounds(): List = + typeParameters.map { parameter -> + parameter + (typeParameterBounds[parameter]?.let { " : $it" } ?: "") + } + + fun asStringWithoutBounds(): String = + name + if (typeParameters.isEmpty()) "" else typeParameters.joinToString(prefix = "<", postfix = ">", separator = ", ") + + override fun equals(other: Any?): Boolean = + other is NameWithTypeParameters && name == other.name + + override fun hashCode(): Int = name.hashCode() override fun toString(): String = - name + if (typeParameters.isEmpty()) "" else typeParameters.joinToString(prefix = "<", postfix = ">", separator = ", ") + name + if (typeParameters.isEmpty()) "" else typeParameters.joinToString(prefix = "<", postfix = ">", separator = ", ") { + val bound = typeParameterBounds[it] + if (bound == null) it else "$it : $bound" + } + + companion object { + private fun String.splitToParametersAndBounds(): Pair, Map> { + val typeParametersWithBounds = drop(1).dropLast(1).split(",").map { it.trim() }.filter { it.isNotBlank() } + val typeParameters = mutableListOf() + val bounds = mutableMapOf() + for (parameterWithBounds in typeParametersWithBounds) { + val parts = parameterWithBounds.split(":").map { it.trim() } + typeParameters += parts[0] + if (parts.size > 1) { + bounds[parts[0]] = parts[1] + } + } + return typeParameters to bounds + } + } } private val references = mutableMapOf>() @@ -66,9 +106,9 @@ class DataCollector { references[classNameWithParameters] = listOfNotNull(manual.toNameWithTypeParameters()) } else { references[classNameWithParameters] = - klass.superTypeListEntries.mapNotNull { - it.toNameWithTypeParameters() - } + klass.superTypeListEntries.mapNotNull { + it.toNameWithTypeParameters() + } } } diff --git a/compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt b/compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt index f5f57e71489..f6b4745f144 100644 --- a/compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt +++ b/compiler/fir/tree/visitors-generator/src/ParametricTransformerGenerator.kt @@ -20,7 +20,7 @@ class ParametricTransformerGenerator(data: DataCollector.ReferencesData) : Abstr "data" to NameWithTypeParameters("D") ), constructCompositeBoxType("E"), - typeParameters = listOf("E : $FIR_ELEMENT_CLASS_NAME"), + typeParametersWithBounds = listOf("E : $FIR_ELEMENT_CLASS_NAME"), body = null ) @@ -63,7 +63,7 @@ class ParametricTransformerGenerator(data: DataCollector.ReferencesData) : Abstr returnType = constructCompositeBoxType(FIR_ELEMENT_CLASS_NAME.name), override = true, final = true, - typeParameters = className.typeParameters + typeParametersWithBounds = className.typeParametersWithBounds() ) { print("return ") generateCall("transform$shortcutName", listOf(parameterName, "data")) @@ -87,7 +87,7 @@ class ParametricTransformerGenerator(data: DataCollector.ReferencesData) : Abstr "data" to NameWithTypeParameters("D") ), constructCompositeBoxType("E"), - typeParameters = listOf("E : $parent") + className.typeParameters + typeParametersWithBounds = listOf("E : $parent") + className.typeParametersWithBounds() ) { print("return ") generateCall("transform${parent.name.classNameWithoutFir}", listOf(parameterName, "data")) @@ -101,7 +101,7 @@ class ParametricTransformerGenerator(data: DataCollector.ReferencesData) : Abstr "data" to NameWithTypeParameters("D") ), constructCompositeBoxType(baseType.name), - typeParameters = className.typeParameters + typeParametersWithBounds = className.typeParametersWithBounds() ) { print("return ") generateCall("transform${parent.name.classNameWithoutFir}", listOf(parameterName, "data")) diff --git a/compiler/fir/tree/visitors-generator/src/SimpleVisitorGenerator.kt b/compiler/fir/tree/visitors-generator/src/SimpleVisitorGenerator.kt index aa2b90d6303..d5b29d7d30d 100644 --- a/compiler/fir/tree/visitors-generator/src/SimpleVisitorGenerator.kt +++ b/compiler/fir/tree/visitors-generator/src/SimpleVisitorGenerator.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.fir.visitors.generator +import org.jetbrains.kotlin.fir.visitors.generator.DataCollector.NameWithTypeParameters import org.jetbrains.kotlin.utils.Printer class SimpleVisitorGenerator(referencesData: DataCollector.ReferencesData) : AbstractVisitorGenerator(referencesData) { @@ -15,11 +16,12 @@ class SimpleVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abs "visitElement", parameters = mapOf( "element" to FIR_ELEMENT_CLASS_NAME, - "data" to DataCollector.NameWithTypeParameters("D") + "data" to NameWithTypeParameters("D") ), returnType = "R", body = null ) + referencesData.walkHierarchyTopDown(from = FIR_ELEMENT_CLASS_NAME) { parent, element -> generateVisit(element, parent) } @@ -27,9 +29,10 @@ class SimpleVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abs println("}") } + private fun Printer.generateVisit( - className: DataCollector.NameWithTypeParameters, - parent: DataCollector.NameWithTypeParameters + className: NameWithTypeParameters, + parent: NameWithTypeParameters ) { val shortcutName = className.name.classNameWithoutFir val parameterName = shortcutName.decapitalize().safeName @@ -37,10 +40,10 @@ class SimpleVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abs name = "visit$shortcutName", parameters = mapOf( parameterName to className, - "data" to DataCollector.NameWithTypeParameters("D") + "data" to NameWithTypeParameters("D") ), returnType = "R", - typeParameters = className.typeParameters + typeParametersWithBounds = className.typeParametersWithBounds() ) { print("return ") generateCall("visit${parent.name.classNameWithoutFir}", listOf(parameterName, "data")) diff --git a/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt b/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt index 769e39a5ace..107359a77d8 100644 --- a/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt +++ b/compiler/fir/tree/visitors-generator/src/UnitVisitorGenerator.kt @@ -21,8 +21,8 @@ class UnitVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abstr body = null ) - referencesData.walkHierarchyTopDown(FIR_ELEMENT_CLASS_NAME) { parent, klass -> - generateVisit(klass, parent) + referencesData.walkHierarchyTopDown(from = FIR_ELEMENT_CLASS_NAME) { parent, element -> + generateVisit(element, parent) } allElementTypes().forEach { @@ -46,7 +46,7 @@ class UnitVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abstr parameterName to className ), returnType = "Unit", - typeParameters = className.typeParameters + typeParametersWithBounds = className.typeParametersWithBounds() ) { printIndent() generateCall("visit${parent.name.classNameWithoutFir}", listOf(parameterName, "null")) @@ -66,7 +66,7 @@ class UnitVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abstr returnType = "Unit", override = true, final = true, - typeParameters = className.typeParameters + typeParametersWithBounds = className.typeParametersWithBounds() ) { printIndent() generateCall("visit$shortcutName", listOf(parameterName)) 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 index 3ce7920fdc5..e0756e38e17 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt @@ -198,14 +198,38 @@ abstract class FirTransformer : FirVisitor { + return transformAnnotationCall(annotationCall, data) + } + + final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): CompositeTransformResult { + return transformAnonymousInitializer(anonymousInitializer, data) + } + + final override fun visitBody(body: FirBody, data: D): CompositeTransformResult { + return transformBody(body, data) + } + final override fun visitCall(call: FirCall, data: D): CompositeTransformResult { return transformCall(call, data) } + final override fun visitCallableMember(callableMember: FirCallableMember, data: D): CompositeTransformResult { + return transformCallableMember(callableMember, data) + } + final override fun visitClass(klass: FirClass, data: D): CompositeTransformResult { return transformClass(klass, data) } + final override fun visitConstExpression(constExpression: FirConstExpression, data: D): CompositeTransformResult { + return transformConstExpression(constExpression, data) + } + + final override fun visitConstructor(constructor: FirConstructor, data: D): CompositeTransformResult { + return transformConstructor(constructor, data) + } + final override fun visitDeclaration(declaration: FirDeclaration, data: D): CompositeTransformResult { return transformDeclaration(declaration, data) } @@ -218,18 +242,54 @@ abstract class FirTransformer : FirVisitor { - return transformElement(element, data) + final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult { + return transformDelegatedConstructorCall(delegatedConstructorCall, data) + } + + final override fun visitDelegatedType(delegatedType: FirDelegatedType, data: D): CompositeTransformResult { + return transformDelegatedType(delegatedType, data) + } + + final override fun visitDynamicType(dynamicType: FirDynamicType, data: D): CompositeTransformResult { + return transformDynamicType(dynamicType, data) + } + + final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult { + return transformEnumEntry(enumEntry, data) + } + + final override fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: D): CompositeTransformResult { + return transformErrorDeclaration(errorDeclaration, data) + } + + final override fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult { + return transformErrorExpression(errorExpression, data) + } + + final override fun visitErrorType(errorType: FirErrorType, data: D): CompositeTransformResult { + return transformErrorType(errorType, data) } final override fun visitExpression(expression: FirExpression, data: D): CompositeTransformResult { return transformExpression(expression, data) } + final override fun visitFile(file: FirFile, data: D): CompositeTransformResult { + return transformFile(file, data) + } + final override fun visitFunction(function: FirFunction, data: D): CompositeTransformResult { return transformFunction(function, data) } + final override fun visitFunctionType(functionType: FirFunctionType, data: D): CompositeTransformResult { + return transformFunctionType(functionType, data) + } + + final override fun visitImplicitType(implicitType: FirImplicitType, data: D): CompositeTransformResult { + return transformImplicitType(implicitType, data) + } + final override fun visitImport(import: FirImport, data: D): CompositeTransformResult { return transformImport(import, data) } @@ -242,14 +302,42 @@ abstract class FirTransformer : FirVisitor { + return transformNamedFunction(namedFunction, data) + } + final override fun visitPackageFragment(packageFragment: FirPackageFragment, data: D): CompositeTransformResult { return transformPackageFragment(packageFragment, data) } + final override fun visitProperty(property: FirProperty, data: D): CompositeTransformResult { + return transformProperty(property, data) + } + + final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult { + return transformPropertyAccessor(propertyAccessor, data) + } + + final override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): CompositeTransformResult { + return transformResolvedDeclarationStatus(resolvedDeclarationStatus, data) + } + + final override fun visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: D): CompositeTransformResult { + return transformResolvedFunctionType(resolvedFunctionType, data) + } + + final override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: D): CompositeTransformResult { + return transformResolvedImport(resolvedImport, data) + } + final override fun visitResolvedType(resolvedType: FirResolvedType, data: D): CompositeTransformResult { return transformResolvedType(resolvedType, data) } + final override fun visitStarProjection(starProjection: FirStarProjection, data: D): CompositeTransformResult { + return transformStarProjection(starProjection, data) + } + final override fun visitStatement(statement: FirStatement, data: D): CompositeTransformResult { return transformStatement(statement, data) } @@ -258,42 +346,34 @@ abstract class FirTransformer : FirVisitor { + return transformTypeAlias(typeAlias, data) + } + + final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): CompositeTransformResult { + return transformTypeParameter(typeParameter, data) + } + final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult { return transformTypeProjection(typeProjection, data) } + final override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): CompositeTransformResult { + return transformTypeProjectionWithVariance(typeProjectionWithVariance, 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 visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult { - return transformDelegatedConstructorCall(delegatedConstructorCall, 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 visitUserType(userType: FirUserType, data: D): CompositeTransformResult { + return transformUserType(userType, data) + } + final override fun visitValueParameter(valueParameter: FirValueParameter, data: D): CompositeTransformResult { return transformValueParameter(valueParameter, data) } @@ -302,88 +382,8 @@ abstract class FirTransformer : FirVisitor { - return transformResolvedDeclarationStatus(resolvedDeclarationStatus, data) - } - - final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): CompositeTransformResult { - return transformAnonymousInitializer(anonymousInitializer, data) - } - - final override fun visitBody(body: FirBody, data: D): CompositeTransformResult { - return transformBody(body, data) - } - - final override fun visitConstExpression(constExpression: FirConstExpression, data: D): CompositeTransformResult { - return transformConstExpression(constExpression, data) - } - - final override fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult { - return transformErrorExpression(errorExpression, 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 visitResolvedImport(resolvedImport: FirResolvedImport, data: D): CompositeTransformResult { - return transformResolvedImport(resolvedImport, 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 visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: D): CompositeTransformResult { - return transformResolvedFunctionType(resolvedFunctionType, 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 visitUserType(userType: FirUserType, data: D): CompositeTransformResult { - return transformUserType(userType, data) + final override fun visitElement(element: FirElement, data: D): CompositeTransformResult { + return transformElement(element, data) } } diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt index 448ded11bd3..1968c4784b7 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt @@ -198,14 +198,38 @@ abstract class FirVisitorVoid : FirVisitor() { visitTypeProjection(typeProjectionWithVariance, null) } + final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?) { + visitAnnotationCall(annotationCall) + } + + final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: Nothing?) { + visitAnonymousInitializer(anonymousInitializer) + } + + final override fun visitBody(body: FirBody, data: Nothing?) { + visitBody(body) + } + final override fun visitCall(call: FirCall, data: Nothing?) { visitCall(call) } + final override fun visitCallableMember(callableMember: FirCallableMember, data: Nothing?) { + visitCallableMember(callableMember) + } + final override fun visitClass(klass: FirClass, data: Nothing?) { visitClass(klass) } + final override fun visitConstExpression(constExpression: FirConstExpression, data: Nothing?) { + visitConstExpression(constExpression) + } + + final override fun visitConstructor(constructor: FirConstructor, data: Nothing?) { + visitConstructor(constructor) + } + final override fun visitDeclaration(declaration: FirDeclaration, data: Nothing?) { visitDeclaration(declaration) } @@ -218,18 +242,54 @@ abstract class FirVisitorVoid : FirVisitor() { visitDeclarationWithBody(declarationWithBody) } - final override fun visitElement(element: FirElement, data: Nothing?) { - visitElement(element) + final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: Nothing?) { + visitDelegatedConstructorCall(delegatedConstructorCall) + } + + final override fun visitDelegatedType(delegatedType: FirDelegatedType, data: Nothing?) { + visitDelegatedType(delegatedType) + } + + final override fun visitDynamicType(dynamicType: FirDynamicType, data: Nothing?) { + visitDynamicType(dynamicType) + } + + final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Nothing?) { + visitEnumEntry(enumEntry) + } + + final override fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: Nothing?) { + visitErrorDeclaration(errorDeclaration) + } + + final override fun visitErrorExpression(errorExpression: FirErrorExpression, data: Nothing?) { + visitErrorExpression(errorExpression) + } + + final override fun visitErrorType(errorType: FirErrorType, data: Nothing?) { + visitErrorType(errorType) } final override fun visitExpression(expression: FirExpression, data: Nothing?) { visitExpression(expression) } + final override fun visitFile(file: FirFile, data: Nothing?) { + visitFile(file) + } + final override fun visitFunction(function: FirFunction, data: Nothing?) { visitFunction(function) } + final override fun visitFunctionType(functionType: FirFunctionType, data: Nothing?) { + visitFunctionType(functionType) + } + + final override fun visitImplicitType(implicitType: FirImplicitType, data: Nothing?) { + visitImplicitType(implicitType) + } + final override fun visitImport(import: FirImport, data: Nothing?) { visitImport(import) } @@ -242,14 +302,42 @@ abstract class FirVisitorVoid : FirVisitor() { visitNamedDeclaration(namedDeclaration) } + final override fun visitNamedFunction(namedFunction: FirNamedFunction, data: Nothing?) { + visitNamedFunction(namedFunction) + } + final override fun visitPackageFragment(packageFragment: FirPackageFragment, data: Nothing?) { visitPackageFragment(packageFragment) } + final override fun visitProperty(property: FirProperty, data: Nothing?) { + visitProperty(property) + } + + final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: Nothing?) { + visitPropertyAccessor(propertyAccessor) + } + + final override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: Nothing?) { + visitResolvedDeclarationStatus(resolvedDeclarationStatus) + } + + final override fun visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: Nothing?) { + visitResolvedFunctionType(resolvedFunctionType) + } + + final override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: Nothing?) { + visitResolvedImport(resolvedImport) + } + final override fun visitResolvedType(resolvedType: FirResolvedType, data: Nothing?) { visitResolvedType(resolvedType) } + final override fun visitStarProjection(starProjection: FirStarProjection, data: Nothing?) { + visitStarProjection(starProjection) + } + final override fun visitStatement(statement: FirStatement, data: Nothing?) { visitStatement(statement) } @@ -258,42 +346,34 @@ abstract class FirVisitorVoid : FirVisitor() { visitType(type) } + final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Nothing?) { + visitTypeAlias(typeAlias) + } + + final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: Nothing?) { + visitTypeParameter(typeParameter) + } + final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: Nothing?) { visitTypeProjection(typeProjection) } + final override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: Nothing?) { + visitTypeProjectionWithVariance(typeProjectionWithVariance) + } + final override fun visitTypeWithNullability(typeWithNullability: FirTypeWithNullability, data: Nothing?) { visitTypeWithNullability(typeWithNullability) } - final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?) { - visitAnnotationCall(annotationCall) - } - - final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: Nothing?) { - visitDelegatedConstructorCall(delegatedConstructorCall) - } - - final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Nothing?) { - visitEnumEntry(enumEntry) - } - - final override fun visitCallableMember(callableMember: FirCallableMember, data: Nothing?) { - visitCallableMember(callableMember) - } - - final override fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: Nothing?) { - visitErrorDeclaration(errorDeclaration) - } - - final override fun visitProperty(property: FirProperty, data: Nothing?) { - visitProperty(property) - } - final override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: Nothing?) { visitTypedDeclaration(typedDeclaration) } + final override fun visitUserType(userType: FirUserType, data: Nothing?) { + visitUserType(userType) + } + final override fun visitValueParameter(valueParameter: FirValueParameter, data: Nothing?) { visitValueParameter(valueParameter) } @@ -302,88 +382,8 @@ abstract class FirVisitorVoid : FirVisitor() { visitVariable(variable) } - final override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: Nothing?) { - visitResolvedDeclarationStatus(resolvedDeclarationStatus) - } - - final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: Nothing?) { - visitAnonymousInitializer(anonymousInitializer) - } - - final override fun visitBody(body: FirBody, data: Nothing?) { - visitBody(body) - } - - final override fun visitConstExpression(constExpression: FirConstExpression, data: Nothing?) { - visitConstExpression(constExpression) - } - - final override fun visitErrorExpression(errorExpression: FirErrorExpression, data: Nothing?) { - visitErrorExpression(errorExpression) - } - - final override fun visitConstructor(constructor: FirConstructor, data: Nothing?) { - visitConstructor(constructor) - } - - final override fun visitNamedFunction(namedFunction: FirNamedFunction, data: Nothing?) { - visitNamedFunction(namedFunction) - } - - final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: Nothing?) { - visitPropertyAccessor(propertyAccessor) - } - - final override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: Nothing?) { - visitResolvedImport(resolvedImport) - } - - final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Nothing?) { - visitTypeAlias(typeAlias) - } - - final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: Nothing?) { - visitTypeParameter(typeParameter) - } - - final override fun visitFile(file: FirFile, data: Nothing?) { - visitFile(file) - } - - final override fun visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: Nothing?) { - visitResolvedFunctionType(resolvedFunctionType) - } - - final override fun visitDelegatedType(delegatedType: FirDelegatedType, data: Nothing?) { - visitDelegatedType(delegatedType) - } - - final override fun visitErrorType(errorType: FirErrorType, data: Nothing?) { - visitErrorType(errorType) - } - - final override fun visitImplicitType(implicitType: FirImplicitType, data: Nothing?) { - visitImplicitType(implicitType) - } - - final override fun visitStarProjection(starProjection: FirStarProjection, data: Nothing?) { - visitStarProjection(starProjection) - } - - final override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: Nothing?) { - visitTypeProjectionWithVariance(typeProjectionWithVariance) - } - - final override fun visitDynamicType(dynamicType: FirDynamicType, data: Nothing?) { - visitDynamicType(dynamicType) - } - - final override fun visitFunctionType(functionType: FirFunctionType, data: Nothing?) { - visitFunctionType(functionType) - } - - final override fun visitUserType(userType: FirUserType, data: Nothing?) { - visitUserType(userType) + final override fun visitElement(element: FirElement, data: Nothing?) { + visitElement(element) } }