azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIR/IR generator] Commonize visitor printing logic

Browse Source 
This is a step towards commonizing the code generator between
FIR and IR: KT-61970

Also, don't use kotlinpoet for generating IR visitors (KT-61703)
This commit is contained in:
Sergej Jaskiewicz
2023-09-20 14:13:40 +02:00
committed by Space Team
parent 205a125c5f
commit c5f519f7c7
26 changed files with 2708 additions and 2393 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt
+1 -1
View File
@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.references.*
import org.jetbrains.kotlin.fir.types.*
abstract class FirDefaultVisitor<out R, in D> : FirVisitor<R, D>() {
override fun visitTypeRef(typeRef: FirTypeRef, data: D): R = visitAnnotationContainer(typeRef, data)
override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): R = visitDeclarationStatus(resolvedDeclarationStatus, data)
@@ -188,5 +189,4 @@ abstract class FirDefaultVisitor<out R, in D> : FirVisitor<R, D>() {
override fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): R = visitContractDescription(rawContractDescription, data)
override fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): R = visitContractDescription(resolvedContractDescription, data)
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt
+620 -621
View File
File diff suppressed because it is too large Load Diff
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt
+1 -1
View File
@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.references.*
import org.jetbrains.kotlin.fir.types.*
abstract class FirVisitor<out R, in D> {
abstract fun visitElement(element: FirElement, data: D): R
open fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): R = visitElement(annotationContainer, data)
@@ -328,5 +329,4 @@ abstract class FirVisitor<out R, in D> {
open fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): R = visitElement(rawContractDescription, data)
open fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): R = visitElement(resolvedContractDescription, data)
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt
+621 -621
View File
File diff suppressed because it is too large Load Diff
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt
+4
View File
@@ -734,6 +734,10 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
+field("partiallyResolvedTypeRef", typeRef, nullable = true).withTransform()
}
resolvedErrorReference.configure {
element.customParentInVisitor = resolvedNamedReference
}
intersectionTypeRef.configure {
+field("leftType", typeRef)
+field("rightType", typeRef)
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt
+6 -5
View File
@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
import org.jetbrains.kotlin.fir.tree.generator.context.generatedType
import org.jetbrains.kotlin.fir.tree.generator.context.type
import org.jetbrains.kotlin.fir.tree.generator.printer.VISITOR_PACKAGE
import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.fir.types.ConeErrorType
import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -116,11 +117,11 @@ val annotationResolvePhaseType = generatedType("expressions", "FirAnnotationReso
val typeRefMarkerType = type("mpp", "TypeRefMarker")
val firVisitorType = type("fir.visitors", "FirVisitor", kind = TypeKind.Class)
val firVisitorVoidType = type("fir.visitors", "FirVisitorVoid", kind = TypeKind.Class)
val firDefaultVisitorType = type("fir.visitors", "FirDefaultVisitor", kind = TypeKind.Class)
val firDefaultVisitorVoidType = type("fir.visitors", "FirDefaultVisitorVoid", kind = TypeKind.Class)
val firTransformerType = type("fir.visitors", "FirTransformer", kind = TypeKind.Class)
val firVisitorType = generatedType("visitors", "FirVisitor")
val firVisitorVoidType = generatedType("visitors", "FirVisitorVoid")
val firDefaultVisitorType = generatedType("visitors", "FirDefaultVisitor")
val firDefaultVisitorVoidType = generatedType("visitors", "FirDefaultVisitorVoid")
val firTransformerType = generatedType("visitors", "FirTransformer")
val resolveStateAccessAnnotation = type("fir.declarations", "ResolveStateAccess", kind = TypeKind.Class)
val unresolvedExpressionTypeAccessAnnotation = type("fir.expressions", "UnresolvedExpressionTypeAccess", kind = TypeKind.Class)
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Element.kt
+12
View File
@@ -6,6 +6,7 @@
package org.jetbrains.kotlin.fir.tree.generator.model
import org.jetbrains.kotlin.fir.tree.generator.printer.BASE_PACKAGE
import org.jetbrains.kotlin.fir.tree.generator.printer.safeDecapitalizedName
import org.jetbrains.kotlin.fir.tree.generator.util.set
import org.jetbrains.kotlin.generators.tree.*
import org.jetbrains.kotlin.generators.tree.ElementOrRef as GenericElementOrRef
@@ -78,6 +79,17 @@ class Element(override val name: String, override val propertyName: String, kind
var baseTransformerType: Element? = null
val transformerType: Element get() = baseTransformerType ?: this
override val visitFunctionName: String
get() = "visit$name"
override val visitorParameterName: String
get() = safeDecapitalizedName
var customParentInVisitor: Element? = null
override val parentInVisitor: Element?
get() = customParentInVisitor ?: elementParents.singleOrNull()?.element?.takeIf { !it.isRootElement }
var doesNotNeedImplementation: Boolean = false
val needTransformOtherChildren: Boolean get() = _needTransformOtherChildren || elementParents.any { it.element.needTransformOtherChildren }
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt
+2 -2
View File
@@ -40,7 +40,7 @@ fun SmartPrinter.printElement(element: Element) {
printKDoc(element.extendedKDoc())
print("${kind!!.title} $typeName")
print(typeParameters())
print(params.typeParameters())
val parentRefs = element.parentRefs
if (parentRefs.isNotEmpty()) {
print(
@@ -49,7 +49,7 @@ fun SmartPrinter.printElement(element: Element) {
}
)
}
print(multipleUpperBoundsList())
print(params.multipleUpperBoundsList())
println(" {")
withIndent {
allFields.forEach { field ->
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/implementation.kt
+1 -1
View File
@@ -67,7 +67,7 @@ fun SmartPrinter.printImplementation(implementation: Implementation) {
print("internal ")
}
print("${kind!!.title} ${this.typeName}")
print(element.typeParameters(end = " "))
print(element.params.typeParameters(end = " "))
val isInterface = kind == ImplementationKind.Interface || kind == ImplementationKind.SealedInterface
val isAbstract = kind == ImplementationKind.AbstractClass || kind == ImplementationKind.SealedClass
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt
+84 -48
View File
@@ -5,71 +5,107 @@
package org.jetbrains.kotlin.fir.tree.generator.printer
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
import org.jetbrains.kotlin.fir.tree.generator.firTransformerType
import org.jetbrains.kotlin.fir.tree.generator.firVisitorType
import org.jetbrains.kotlin.fir.tree.generator.model.Element
import org.jetbrains.kotlin.fir.tree.generator.model.Field
import org.jetbrains.kotlin.generators.tree.*
import org.jetbrains.kotlin.generators.tree.printer.FunctionParameter
import org.jetbrains.kotlin.generators.tree.printer.GeneratedFile
import org.jetbrains.kotlin.generators.tree.printer.multipleUpperBoundsList
import org.jetbrains.kotlin.generators.tree.printer.printFunctionDeclaration
import org.jetbrains.kotlin.generators.tree.printer.printGeneratedType
import org.jetbrains.kotlin.generators.tree.printer.typeParameters
import org.jetbrains.kotlin.generators.tree.render
import org.jetbrains.kotlin.types.Variance
import org.jetbrains.kotlin.utils.SmartPrinter
import org.jetbrains.kotlin.utils.withIndent
import java.io.File
fun printTransformer(elements: List<Element>, generationPath: File): GeneratedFile =
printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, "FirTransformer") {
println()
println("abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {")
println()
withIndent {
println("abstract fun <E : FirElement> transformElement(element: E, data: D): E")
private class TransformerPrinter(
printer: SmartPrinter,
) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
override val visitorType: ClassRef<*>
get() = firTransformerType
override val visitorSuperType: ClassRef<PositionTypeParameterRef>
get() = firVisitorType.withArgs(AbstractFirTreeBuilder.baseFirElement, visitorDataType)
override val visitorTypeParameters: List<TypeVariable>
get() = listOf(dataTypeVariable)
override val visitorDataType: TypeRef
get() = dataTypeVariable
override fun visitMethodReturnType(element: Element) = element.transformerType
override val allowTypeParametersInVisitorMethods: Boolean
get() = true
context(ImportCollector)
override fun printMethodsForElement(element: Element) {
printer.run {
println()
for (element in elements) {
if (element == AbstractFirTreeBuilder.baseFirElement) continue
val varName = element.safeDecapitalizedName
print("open fun ")
element.typeParameters(end = " ").takeIf { it.isNotBlank() }?.let { print(it) }
println(
"transform",
element.name,
"(",
varName,
": ",
element.render(),
", data: D): ",
element.transformerType.render(),
element.multipleUpperBoundsList(),
" {",
val elementParameterName = element.safeDecapitalizedName
if (element.isRootElement) {
val elementTP = TypeVariable("E", listOf(element), variance = Variance.INVARIANT)
printFunctionDeclaration(
name = "transformElement",
parameters = listOf(
FunctionParameter(elementParameterName, elementTP),
FunctionParameter("data", dataTypeVariable)
),
returnType = elementTP,
typeParameters = listOf(elementTP),
modality = Modality.ABSTRACT,
)
println()
} else {
printFunctionDeclaration(
name = "transform" + element.name,
parameters = listOf(
FunctionParameter(elementParameterName, element),
FunctionParameter("data", dataTypeVariable)
),
returnType = visitMethodReturnType(element),
typeParameters = element.params,
modality = Modality.OPEN,
)
println(" {")
withIndent {
println("return transformElement($varName, data)")
println("return transformElement(", elementParameterName, ", data)")
}
println("}")
println()
}
for (element in elements) {
val varName = element.safeDecapitalizedName
print("final override fun ")
element.typeParameters(end = " ").takeIf { it.isNotBlank() }?.let { print(it) }
println()
printVisitMethodDeclaration(
element = element,
modality = Modality.FINAL,
override = true,
)
println(" {")
withIndent {
println(
"visit",
"return transform",
element.name,
"(",
varName,
": ",
element.render(),
", data: D): ",
element.transformerType.render(),
element.multipleUpperBoundsList(),
" {"
element.safeDecapitalizedName,
", ",
"data)"
)
withIndent {
println("return transform${element.name}($varName, data)")
}
println("}")
println()
}
println("}")
}
println("}")
}
}
fun printTransformer(elements: List<Element>, generationPath: File): GeneratedFile =
printGeneratedType(
generationPath,
TREE_GENERATOR_README,
firTransformerType.packageName,
firTransformerType.simpleName,
) {
println()
TransformerPrinter(this).printVisitor(elements)
}
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/visitor.kt
+97 -152
View File
@@ -5,176 +5,121 @@
package org.jetbrains.kotlin.fir.tree.generator.printer
import org.jetbrains.kotlin.fir.tree.generator.FirTreeBuilder
import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
import org.jetbrains.kotlin.fir.tree.generator.firDefaultVisitorType
import org.jetbrains.kotlin.fir.tree.generator.firDefaultVisitorVoidType
import org.jetbrains.kotlin.fir.tree.generator.firVisitorType
import org.jetbrains.kotlin.fir.tree.generator.firVisitorVoidType
import org.jetbrains.kotlin.fir.tree.generator.model.Element
import org.jetbrains.kotlin.fir.tree.generator.model.Field
import org.jetbrains.kotlin.generators.tree.*
import org.jetbrains.kotlin.generators.tree.printer.GeneratedFile
import org.jetbrains.kotlin.generators.tree.printer.multipleUpperBoundsList
import org.jetbrains.kotlin.generators.tree.printer.printGeneratedType
import org.jetbrains.kotlin.generators.tree.printer.typeParameters
import org.jetbrains.kotlin.generators.tree.render
import org.jetbrains.kotlin.utils.withIndent
import org.jetbrains.kotlin.utils.SmartPrinter
import java.io.File
private val elementsWithMultipleSupertypesForDefaultVisitor = mapOf(
FirTreeBuilder.resolvedErrorReference to FirTreeBuilder.resolvedNamedReference
)
private class VisitorPrinter(
printer: SmartPrinter,
override val visitorType: ClassRef<*>,
visitSuperTypeByDefault: Boolean,
) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault) {
private fun Element.isAcceptableForDefaultVisiting(): Boolean {
if (this == AbstractFirTreeBuilder.baseFirElement) return false
val hasSingleSupertype = elementParents.size == 1 && !elementParents[0].element.isRootElement
return hasSingleSupertype || this in elementsWithMultipleSupertypesForDefaultVisitor
}
override val visitorTypeParameters: List<TypeVariable>
get() = listOf(resultTypeVariable, dataTypeVariable)
private fun Element.getNameOfSupertypeForDefaultVisiting(): String {
val parentForDefaultVisiting =
elementParents.singleOrNull()?.element ?: elementsWithMultipleSupertypesForDefaultVisitor.getValue(this)
return parentForDefaultVisiting.name
}
override val visitorSuperType: ClassRef<PositionTypeParameterRef>? =
firVisitorType.takeIf { visitSuperTypeByDefault }?.withArgs(resultTypeVariable, dataTypeVariable)
fun printVisitor(elements: List<Element>, generationPath: File, visitSuperTypeByDefault: Boolean): GeneratedFile {
val className = if (visitSuperTypeByDefault) "FirDefaultVisitor" else "FirVisitor"
return printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, className) {
println()
override val visitorDataType: TypeRef
get() = dataTypeVariable
print("abstract class $className<out R, in D> ")
if (visitSuperTypeByDefault) {
print(": FirVisitor<R, D>() ")
}
println("{")
override fun visitMethodReturnType(element: Element) = resultTypeVariable
pushIndent()
if (!visitSuperTypeByDefault) {
println("abstract fun visitElement(element: FirElement, data: D): R\n")
}
for (element in elements) {
if (element == AbstractFirTreeBuilder.baseFirElement) continue
if (visitSuperTypeByDefault && !element.isAcceptableForDefaultVisiting()) continue
with(element) {
val varName = safeDecapitalizedName
if (visitSuperTypeByDefault) {
print("override")
} else {
print("open")
}
print(
" fun ",
typeParameters(end = " "),
"visit",
name,
"(",
varName,
": ",
render(),
", data: D): R",
multipleUpperBoundsList(),
" = visit"
)
if (visitSuperTypeByDefault) {
print(element.getNameOfSupertypeForDefaultVisiting())
} else {
print("Element")
}
println("($varName, data)")
println()
}
}
popIndent()
println("}")
override val allowTypeParametersInVisitorMethods: Boolean
get() = true
override fun parentInVisitor(element: Element): Element? = when {
element.isRootElement -> null
visitSuperTypeByDefault -> element.parentInVisitor
else -> AbstractFirTreeBuilder.baseFirElement
}
}
fun printVisitor(elements: List<Element>, generationPath: File, visitSuperTypeByDefault: Boolean) =
printVisitorCommon(
elements,
generationPath,
if (visitSuperTypeByDefault) firDefaultVisitorType else firVisitorType,
) { printer, visitorType ->
VisitorPrinter(printer, visitorType, visitSuperTypeByDefault)
}
fun printVisitorVoid(elements: List<Element>, generationPath: File): GeneratedFile =
printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, "FirVisitorVoid") {
println()
println("abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {")
private class VisitorVoidPrinter(
printer: SmartPrinter,
override val visitorType: ClassRef<*>,
) : AbstractVisitorVoidPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
withIndent {
println("abstract fun visitElement(element: FirElement)")
override val visitorSuperClass: ClassRef<PositionTypeParameterRef>
get() = firVisitorType
override val allowTypeParametersInVisitorMethods: Boolean
get() = true
override val useAbstractMethodForRootElement: Boolean
get() = true
override val overriddenVisitMethodsAreFinal: Boolean
get() = true
override fun parentInVisitor(element: Element): Element = AbstractFirTreeBuilder.baseFirElement
}
fun printVisitorVoid(elements: List<Element>, generationPath: File) =
printVisitorCommon(elements, generationPath, firVisitorVoidType, ::VisitorVoidPrinter)
private class DefaultVisitorVoidPrinter(
printer: SmartPrinter,
override val visitorType: ClassRef<*>,
) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = true) {
override val visitorTypeParameters: List<TypeVariable>
get() = emptyList()
override val visitorDataType: TypeRef
get() = StandardTypes.nothing.copy(nullable = true)
override fun visitMethodReturnType(element: Element) = StandardTypes.unit
override val visitorSuperType: ClassRef<PositionTypeParameterRef>
get() = firVisitorVoidType
override val allowTypeParametersInVisitorMethods: Boolean
get() = true
context(ImportCollector)
override fun printMethodsForElement(element: Element) {
printer.run {
printVisitMethodDeclaration(
element,
hasDataParameter = false,
override = true,
)
println(" = ", element.parentInVisitor!!.visitFunctionName, "(", element.visitorParameterName, ")")
println()
for (element in elements) {
if (element == AbstractFirTreeBuilder.baseFirElement) continue
with(element) {
val varName = safeDecapitalizedName
println(
"open fun ",
typeParameters(end = " "),
"visit",
name,
"(",
varName,
": ",
render(),
")",
multipleUpperBoundsList(),
" {"
)
withIndent {
println("visitElement($varName)")
}
println("}")
println()
}
}
for (element in elements) {
with(element) {
val varName = safeDecapitalizedName
println(
"final override fun ",
typeParameters(end = " "),
"visit",
name,
"(",
varName,
": ",
render(),
", data: Nothing?)",
multipleUpperBoundsList(),
" {"
)
withIndent {
println("visit$name($varName)")
}
println("}")
println()
}
}
}
println("}")
}
}
fun printDefaultVisitorVoid(elements: List<Element>, generationPath: File): GeneratedFile =
printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, "FirDefaultVisitorVoid") {
fun printDefaultVisitorVoid(elements: List<Element>, generationPath: File) =
printVisitorCommon(elements, generationPath, firDefaultVisitorVoidType, ::DefaultVisitorVoidPrinter)
private fun printVisitorCommon(
elements: List<Element>,
generationPath: File,
visitorType: ClassRef<*>,
makePrinter: (SmartPrinter, ClassRef<*>) -> AbstractVisitorPrinter<Element, Field>,
): GeneratedFile =
printGeneratedType(generationPath, TREE_GENERATOR_README, visitorType.packageName, visitorType.simpleName) {
println()
println("abstract class FirDefaultVisitorVoid : FirVisitorVoid() {")
pushIndent()
for (element in elements) {
if (!element.isAcceptableForDefaultVisiting()) continue
with(element) {
val varName = safeDecapitalizedName
println(
"override fun ",
typeParameters(end = " "),
"visit",
name,
"(",
varName,
": ",
render(),
")",
multipleUpperBoundsList(),
" = visit",
getNameOfSupertypeForDefaultVisiting(),
"(",
varName,
")"
)
println()
}
}
popIndent()
println("}")
}
makePrinter(this, visitorType).printVisitor(elements)
}
compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt
+111 -192
View File
@@ -10,90 +10,11 @@ package org.jetbrains.kotlin.ir.visitors
import org.jetbrains.kotlin.ir.IrElement
import org.jetbrains.kotlin.ir.IrStatement
import org.jetbrains.kotlin.ir.declarations.IrAnonymousInitializer
import org.jetbrains.kotlin.ir.declarations.IrClass
import org.jetbrains.kotlin.ir.declarations.IrConstructor
import org.jetbrains.kotlin.ir.declarations.IrDeclarationBase
import org.jetbrains.kotlin.ir.declarations.IrEnumEntry
import org.jetbrains.kotlin.ir.declarations.IrErrorDeclaration
import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment
import org.jetbrains.kotlin.ir.declarations.IrField
import org.jetbrains.kotlin.ir.declarations.IrFile
import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty
import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
import org.jetbrains.kotlin.ir.declarations.IrProperty
import org.jetbrains.kotlin.ir.declarations.IrScript
import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
import org.jetbrains.kotlin.ir.declarations.IrTypeAlias
import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
import org.jetbrains.kotlin.ir.declarations.IrValueParameter
import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.expressions.IrBlock
import org.jetbrains.kotlin.ir.expressions.IrBlockBody
import org.jetbrains.kotlin.ir.expressions.IrBody
import org.jetbrains.kotlin.ir.expressions.IrBranch
import org.jetbrains.kotlin.ir.expressions.IrBreak
import org.jetbrains.kotlin.ir.expressions.IrBreakContinue
import org.jetbrains.kotlin.ir.expressions.IrCall
import org.jetbrains.kotlin.ir.expressions.IrCallableReference
import org.jetbrains.kotlin.ir.expressions.IrCatch
import org.jetbrains.kotlin.ir.expressions.IrClassReference
import org.jetbrains.kotlin.ir.expressions.IrComposite
import org.jetbrains.kotlin.ir.expressions.IrConst
import org.jetbrains.kotlin.ir.expressions.IrConstantArray
import org.jetbrains.kotlin.ir.expressions.IrConstantObject
import org.jetbrains.kotlin.ir.expressions.IrConstantPrimitive
import org.jetbrains.kotlin.ir.expressions.IrConstantValue
import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
import org.jetbrains.kotlin.ir.expressions.IrContainerExpression
import org.jetbrains.kotlin.ir.expressions.IrContinue
import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference
import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall
import org.jetbrains.kotlin.ir.expressions.IrDoWhileLoop
import org.jetbrains.kotlin.ir.expressions.IrDynamicExpression
import org.jetbrains.kotlin.ir.expressions.IrDynamicMemberExpression
import org.jetbrains.kotlin.ir.expressions.IrDynamicOperatorExpression
import org.jetbrains.kotlin.ir.expressions.IrElseBranch
import org.jetbrains.kotlin.ir.expressions.IrEnumConstructorCall
import org.jetbrains.kotlin.ir.expressions.IrErrorCallExpression
import org.jetbrains.kotlin.ir.expressions.IrErrorExpression
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression
import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
import org.jetbrains.kotlin.ir.expressions.IrFunctionExpression
import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
import org.jetbrains.kotlin.ir.expressions.IrGetClass
import org.jetbrains.kotlin.ir.expressions.IrGetEnumValue
import org.jetbrains.kotlin.ir.expressions.IrGetField
import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue
import org.jetbrains.kotlin.ir.expressions.IrGetSingletonValue
import org.jetbrains.kotlin.ir.expressions.IrGetValue
import org.jetbrains.kotlin.ir.expressions.IrInstanceInitializerCall
import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference
import org.jetbrains.kotlin.ir.expressions.IrLoop
import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
import org.jetbrains.kotlin.ir.expressions.IrPropertyReference
import org.jetbrains.kotlin.ir.expressions.IrRawFunctionReference
import org.jetbrains.kotlin.ir.expressions.IrReturn
import org.jetbrains.kotlin.ir.expressions.IrSetField
import org.jetbrains.kotlin.ir.expressions.IrSetValue
import org.jetbrains.kotlin.ir.expressions.IrSpreadElement
import org.jetbrains.kotlin.ir.expressions.IrStringConcatenation
import org.jetbrains.kotlin.ir.expressions.IrSuspendableExpression
import org.jetbrains.kotlin.ir.expressions.IrSuspensionPoint
import org.jetbrains.kotlin.ir.expressions.IrSyntheticBody
import org.jetbrains.kotlin.ir.expressions.IrThrow
import org.jetbrains.kotlin.ir.expressions.IrTry
import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall
import org.jetbrains.kotlin.ir.expressions.IrValueAccessExpression
import org.jetbrains.kotlin.ir.expressions.IrVararg
import org.jetbrains.kotlin.ir.expressions.IrWhen
import org.jetbrains.kotlin.ir.expressions.IrWhileLoop
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
override fun visitElement(element: IrElement, data: D): IrElement {
element.transformChildren(this, data)
return element
@@ -105,61 +26,59 @@ interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
}
override fun visitValueParameter(declaration: IrValueParameter, data: D): IrStatement =
visitDeclaration(declaration, data)
visitDeclaration(declaration, data)
override fun visitClass(declaration: IrClass, data: D): IrStatement =
visitDeclaration(declaration, data)
visitDeclaration(declaration, data)
override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D):
IrStatement = visitDeclaration(declaration, data)
override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): IrStatement =
visitDeclaration(declaration, data)
override fun visitTypeParameter(declaration: IrTypeParameter, data: D): IrStatement =
visitDeclaration(declaration, data)
visitDeclaration(declaration, data)
override fun visitFunction(declaration: IrFunction, data: D): IrStatement =
visitDeclaration(declaration, data)
visitDeclaration(declaration, data)
override fun visitConstructor(declaration: IrConstructor, data: D): IrStatement =
visitFunction(declaration, data)
visitFunction(declaration, data)
override fun visitEnumEntry(declaration: IrEnumEntry, data: D): IrStatement =
visitDeclaration(declaration, data)
visitDeclaration(declaration, data)
override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D):
IrStatement = visitDeclaration(declaration, data)
override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): IrStatement =
visitDeclaration(declaration, data)
override fun visitField(declaration: IrField, data: D): IrStatement =
visitDeclaration(declaration, data)
visitDeclaration(declaration, data)
override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty,
data: D): IrStatement = visitDeclaration(declaration, data)
override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): IrStatement =
visitDeclaration(declaration, data)
override fun visitModuleFragment(declaration: IrModuleFragment, data: D):
IrModuleFragment {
override fun visitModuleFragment(declaration: IrModuleFragment, data: D): IrModuleFragment {
declaration.transformChildren(this, data)
return declaration
}
override fun visitProperty(declaration: IrProperty, data: D): IrStatement =
visitDeclaration(declaration, data)
visitDeclaration(declaration, data)
override fun visitScript(declaration: IrScript, data: D): IrStatement =
visitDeclaration(declaration, data)
visitDeclaration(declaration, data)
override fun visitSimpleFunction(declaration: IrSimpleFunction, data: D): IrStatement =
visitFunction(declaration, data)
visitFunction(declaration, data)
override fun visitTypeAlias(declaration: IrTypeAlias, data: D): IrStatement =
visitDeclaration(declaration, data)
visitDeclaration(declaration, data)
override fun visitVariable(declaration: IrVariable, data: D): IrStatement =
visitDeclaration(declaration, data)
visitDeclaration(declaration, data)
override fun visitPackageFragment(declaration: IrPackageFragment, data: D): IrElement =
visitElement(declaration, data)
visitElement(declaration, data)
override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment,
data: D): IrExternalPackageFragment {
override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: D): IrExternalPackageFragment {
declaration.transformChildren(this, data)
return declaration
}
@@ -180,156 +99,156 @@ interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
}
override fun visitExpressionBody(body: IrExpressionBody, data: D): IrBody =
visitBody(body, data)
visitBody(body, data)
override fun visitBlockBody(body: IrBlockBody, data: D): IrBody = visitBody(body, data)
override fun visitBlockBody(body: IrBlockBody, data: D): IrBody =
visitBody(body, data)
override fun visitDeclarationReference(expression: IrDeclarationReference, data: D):
IrExpression = visitExpression(expression, data)
override fun visitDeclarationReference(expression: IrDeclarationReference, data: D): IrExpression =
visitExpression(expression, data)
override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D):
IrElement = visitDeclarationReference(expression, data)
override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): IrElement =
visitDeclarationReference(expression, data)
override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D):
IrElement = visitMemberAccess(expression, data)
override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): IrElement =
visitMemberAccess(expression, data)
override fun visitConstructorCall(expression: IrConstructorCall, data: D): IrElement =
visitFunctionAccess(expression, data)
visitFunctionAccess(expression, data)
override fun visitSingletonReference(expression: IrGetSingletonValue, data: D):
IrExpression = visitDeclarationReference(expression, data)
override fun visitSingletonReference(expression: IrGetSingletonValue, data: D): IrExpression =
visitDeclarationReference(expression, data)
override fun visitGetObjectValue(expression: IrGetObjectValue, data: D): IrExpression =
visitSingletonReference(expression, data)
visitSingletonReference(expression, data)
override fun visitGetEnumValue(expression: IrGetEnumValue, data: D): IrExpression =
visitSingletonReference(expression, data)
visitSingletonReference(expression, data)
override fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D):
IrExpression = visitDeclarationReference(expression, data)
override fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): IrExpression =
visitDeclarationReference(expression, data)
override fun visitContainerExpression(expression: IrContainerExpression, data: D):
IrExpression = visitExpression(expression, data)
override fun visitContainerExpression(expression: IrContainerExpression, data: D): IrExpression =
visitExpression(expression, data)
override fun visitBlock(expression: IrBlock, data: D): IrExpression =
visitContainerExpression(expression, data)
visitContainerExpression(expression, data)
override fun visitComposite(expression: IrComposite, data: D): IrExpression =
visitContainerExpression(expression, data)
visitContainerExpression(expression, data)
override fun visitSyntheticBody(body: IrSyntheticBody, data: D): IrBody =
visitBody(body, data)
visitBody(body, data)
override fun visitBreakContinue(jump: IrBreakContinue, data: D): IrExpression =
visitExpression(jump, data)
visitExpression(jump, data)
override fun visitBreak(jump: IrBreak, data: D): IrExpression =
visitBreakContinue(jump, data)
visitBreakContinue(jump, data)
override fun visitContinue(jump: IrContinue, data: D): IrExpression =
visitBreakContinue(jump, data)
visitBreakContinue(jump, data)
override fun visitCall(expression: IrCall, data: D): IrElement =
visitFunctionAccess(expression, data)
visitFunctionAccess(expression, data)
override fun visitCallableReference(expression: IrCallableReference<*>, data: D):
IrElement = visitMemberAccess(expression, data)
override fun visitCallableReference(expression: IrCallableReference<*>, data: D): IrElement =
visitMemberAccess(expression, data)
override fun visitFunctionReference(expression: IrFunctionReference, data: D):
IrElement = visitCallableReference(expression, data)
override fun visitFunctionReference(expression: IrFunctionReference, data: D): IrElement =
visitCallableReference(expression, data)
override fun visitPropertyReference(expression: IrPropertyReference, data: D):
IrElement = visitCallableReference(expression, data)
override fun visitPropertyReference(expression: IrPropertyReference, data: D): IrElement =
visitCallableReference(expression, data)
override
fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference,
data: D): IrElement = visitCallableReference(expression, data)
override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: D): IrElement =
visitCallableReference(expression, data)
override fun visitClassReference(expression: IrClassReference, data: D): IrExpression =
visitDeclarationReference(expression, data)
visitDeclarationReference(expression, data)
override fun visitConst(expression: IrConst<*>, data: D): IrExpression =
visitExpression(expression, data)
visitExpression(expression, data)
override fun visitConstantValue(expression: IrConstantValue, data: D):
IrConstantValue {
override fun visitConstantValue(expression: IrConstantValue, data: D): IrConstantValue {
expression.transformChildren(this, data)
return expression
}
override fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D):
IrConstantValue = visitConstantValue(expression, data)
override fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): IrConstantValue =
visitConstantValue(expression, data)
override fun visitConstantObject(expression: IrConstantObject, data: D):
IrConstantValue = visitConstantValue(expression, data)
override fun visitConstantObject(expression: IrConstantObject, data: D): IrConstantValue =
visitConstantValue(expression, data)
override fun visitConstantArray(expression: IrConstantArray, data: D): IrConstantValue
= visitConstantValue(expression, data)
override fun visitConstantArray(expression: IrConstantArray, data: D): IrConstantValue =
visitConstantValue(expression, data)
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall,
data: D): IrElement = visitFunctionAccess(expression, data)
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: D): IrElement =
visitFunctionAccess(expression, data)
override fun visitDynamicExpression(expression: IrDynamicExpression, data: D):
IrExpression = visitExpression(expression, data)
override fun visitDynamicExpression(expression: IrDynamicExpression, data: D): IrExpression =
visitExpression(expression, data)
override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression,
data: D): IrExpression = visitDynamicExpression(expression, data)
override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D): IrExpression =
visitDynamicExpression(expression, data)
override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression,
data: D): IrExpression = visitDynamicExpression(expression, data)
override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D): IrExpression =
visitDynamicExpression(expression, data)
override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D):
IrElement = visitFunctionAccess(expression, data)
override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): IrElement =
visitFunctionAccess(expression, data)
override fun visitErrorExpression(expression: IrErrorExpression, data: D): IrExpression
= visitExpression(expression, data)
override fun visitErrorExpression(expression: IrErrorExpression, data: D): IrExpression =
visitExpression(expression, data)
override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D):
IrExpression = visitErrorExpression(expression, data)
override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): IrExpression =
visitErrorExpression(expression, data)
override fun visitFieldAccess(expression: IrFieldAccessExpression, data: D):
IrExpression = visitDeclarationReference(expression, data)
override fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): IrExpression =
visitDeclarationReference(expression, data)
override fun visitGetField(expression: IrGetField, data: D): IrExpression =
visitFieldAccess(expression, data)
visitFieldAccess(expression, data)
override fun visitSetField(expression: IrSetField, data: D): IrExpression =
visitFieldAccess(expression, data)
visitFieldAccess(expression, data)
override fun visitFunctionExpression(expression: IrFunctionExpression, data: D):
IrElement = visitExpression(expression, data)
override fun visitFunctionExpression(expression: IrFunctionExpression, data: D): IrElement =
visitExpression(expression, data)
override fun visitGetClass(expression: IrGetClass, data: D): IrExpression =
visitExpression(expression, data)
visitExpression(expression, data)
override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall,
data: D): IrExpression = visitExpression(expression, data)
override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: D): IrExpression =
visitExpression(expression, data)
override fun visitLoop(loop: IrLoop, data: D): IrExpression = visitExpression(loop,
data)
override fun visitLoop(loop: IrLoop, data: D): IrExpression =
visitExpression(loop, data)
override fun visitWhileLoop(loop: IrWhileLoop, data: D): IrExpression = visitLoop(loop,
data)
override fun visitWhileLoop(loop: IrWhileLoop, data: D): IrExpression =
visitLoop(loop, data)
override fun visitDoWhileLoop(loop: IrDoWhileLoop, data: D): IrExpression =
visitLoop(loop, data)
visitLoop(loop, data)
override fun visitReturn(expression: IrReturn, data: D): IrExpression =
visitExpression(expression, data)
visitExpression(expression, data)
override fun visitStringConcatenation(expression: IrStringConcatenation, data: D):
IrExpression = visitExpression(expression, data)
override fun visitStringConcatenation(expression: IrStringConcatenation, data: D): IrExpression =
visitExpression(expression, data)
override fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): IrExpression
= visitExpression(expression, data)
override fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): IrExpression =
visitExpression(expression, data)
override fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D):
IrExpression = visitExpression(expression, data)
override fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): IrExpression =
visitExpression(expression, data)
override fun visitThrow(expression: IrThrow, data: D): IrExpression =
visitExpression(expression, data)
visitExpression(expression, data)
override fun visitTry(aTry: IrTry, data: D): IrExpression = visitExpression(aTry, data)
override fun visitTry(aTry: IrTry, data: D): IrExpression =
visitExpression(aTry, data)
override fun visitCatch(aCatch: IrCatch, data: D): IrCatch {
aCatch.transformChildren(this, data)
@@ -337,19 +256,19 @@ interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
}
override fun visitTypeOperator(expression: IrTypeOperatorCall, data: D): IrExpression =
visitExpression(expression, data)
visitExpression(expression, data)
override fun visitValueAccess(expression: IrValueAccessExpression, data: D):
IrExpression = visitDeclarationReference(expression, data)
override fun visitValueAccess(expression: IrValueAccessExpression, data: D): IrExpression =
visitDeclarationReference(expression, data)
override fun visitGetValue(expression: IrGetValue, data: D): IrExpression =
visitValueAccess(expression, data)
visitValueAccess(expression, data)
override fun visitSetValue(expression: IrSetValue, data: D): IrExpression =
visitValueAccess(expression, data)
visitValueAccess(expression, data)
override fun visitVararg(expression: IrVararg, data: D): IrExpression =
visitExpression(expression, data)
visitExpression(expression, data)
override fun visitSpreadElement(spread: IrSpreadElement, data: D): IrSpreadElement {
spread.transformChildren(this, data)
@@ -357,7 +276,7 @@ interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
}
override fun visitWhen(expression: IrWhen, data: D): IrExpression =
visitExpression(expression, data)
visitExpression(expression, data)
override fun visitBranch(branch: IrBranch, data: D): IrBranch {
branch.transformChildren(this, data)
compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt
+63 -202
View File
@@ -9,152 +9,54 @@
package org.jetbrains.kotlin.ir.visitors
import org.jetbrains.kotlin.ir.IrElement
import org.jetbrains.kotlin.ir.declarations.IrAnonymousInitializer
import org.jetbrains.kotlin.ir.declarations.IrClass
import org.jetbrains.kotlin.ir.declarations.IrConstructor
import org.jetbrains.kotlin.ir.declarations.IrDeclarationBase
import org.jetbrains.kotlin.ir.declarations.IrEnumEntry
import org.jetbrains.kotlin.ir.declarations.IrErrorDeclaration
import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment
import org.jetbrains.kotlin.ir.declarations.IrField
import org.jetbrains.kotlin.ir.declarations.IrFile
import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty
import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
import org.jetbrains.kotlin.ir.declarations.IrProperty
import org.jetbrains.kotlin.ir.declarations.IrScript
import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
import org.jetbrains.kotlin.ir.declarations.IrTypeAlias
import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
import org.jetbrains.kotlin.ir.declarations.IrValueParameter
import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.expressions.IrBlock
import org.jetbrains.kotlin.ir.expressions.IrBlockBody
import org.jetbrains.kotlin.ir.expressions.IrBody
import org.jetbrains.kotlin.ir.expressions.IrBranch
import org.jetbrains.kotlin.ir.expressions.IrBreak
import org.jetbrains.kotlin.ir.expressions.IrBreakContinue
import org.jetbrains.kotlin.ir.expressions.IrCall
import org.jetbrains.kotlin.ir.expressions.IrCallableReference
import org.jetbrains.kotlin.ir.expressions.IrCatch
import org.jetbrains.kotlin.ir.expressions.IrClassReference
import org.jetbrains.kotlin.ir.expressions.IrComposite
import org.jetbrains.kotlin.ir.expressions.IrConst
import org.jetbrains.kotlin.ir.expressions.IrConstantArray
import org.jetbrains.kotlin.ir.expressions.IrConstantObject
import org.jetbrains.kotlin.ir.expressions.IrConstantPrimitive
import org.jetbrains.kotlin.ir.expressions.IrConstantValue
import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
import org.jetbrains.kotlin.ir.expressions.IrContainerExpression
import org.jetbrains.kotlin.ir.expressions.IrContinue
import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference
import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall
import org.jetbrains.kotlin.ir.expressions.IrDoWhileLoop
import org.jetbrains.kotlin.ir.expressions.IrDynamicExpression
import org.jetbrains.kotlin.ir.expressions.IrDynamicMemberExpression
import org.jetbrains.kotlin.ir.expressions.IrDynamicOperatorExpression
import org.jetbrains.kotlin.ir.expressions.IrElseBranch
import org.jetbrains.kotlin.ir.expressions.IrEnumConstructorCall
import org.jetbrains.kotlin.ir.expressions.IrErrorCallExpression
import org.jetbrains.kotlin.ir.expressions.IrErrorExpression
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression
import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
import org.jetbrains.kotlin.ir.expressions.IrFunctionExpression
import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
import org.jetbrains.kotlin.ir.expressions.IrGetClass
import org.jetbrains.kotlin.ir.expressions.IrGetEnumValue
import org.jetbrains.kotlin.ir.expressions.IrGetField
import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue
import org.jetbrains.kotlin.ir.expressions.IrGetSingletonValue
import org.jetbrains.kotlin.ir.expressions.IrGetValue
import org.jetbrains.kotlin.ir.expressions.IrInstanceInitializerCall
import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference
import org.jetbrains.kotlin.ir.expressions.IrLoop
import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
import org.jetbrains.kotlin.ir.expressions.IrPropertyReference
import org.jetbrains.kotlin.ir.expressions.IrRawFunctionReference
import org.jetbrains.kotlin.ir.expressions.IrReturn
import org.jetbrains.kotlin.ir.expressions.IrSetField
import org.jetbrains.kotlin.ir.expressions.IrSetValue
import org.jetbrains.kotlin.ir.expressions.IrSpreadElement
import org.jetbrains.kotlin.ir.expressions.IrStringConcatenation
import org.jetbrains.kotlin.ir.expressions.IrSuspendableExpression
import org.jetbrains.kotlin.ir.expressions.IrSuspensionPoint
import org.jetbrains.kotlin.ir.expressions.IrSyntheticBody
import org.jetbrains.kotlin.ir.expressions.IrThrow
import org.jetbrains.kotlin.ir.expressions.IrTry
import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall
import org.jetbrains.kotlin.ir.expressions.IrValueAccessExpression
import org.jetbrains.kotlin.ir.expressions.IrVararg
import org.jetbrains.kotlin.ir.expressions.IrWhen
import org.jetbrains.kotlin.ir.expressions.IrWhileLoop
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
interface IrElementVisitor<out R, in D> {
fun visitElement(element: IrElement, data: D): R
fun visitDeclaration(declaration: IrDeclarationBase, data: D): R =
visitElement(declaration, data)
fun visitDeclaration(declaration: IrDeclarationBase, data: D): R = visitElement(declaration, data)
fun visitValueParameter(declaration: IrValueParameter, data: D): R =
visitDeclaration(declaration, data)
fun visitValueParameter(declaration: IrValueParameter, data: D): R = visitDeclaration(declaration, data)
fun visitClass(declaration: IrClass, data: D): R = visitDeclaration(declaration, data)
fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): R =
visitDeclaration(declaration, data)
fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): R = visitDeclaration(declaration, data)
fun visitTypeParameter(declaration: IrTypeParameter, data: D): R =
visitDeclaration(declaration, data)
fun visitTypeParameter(declaration: IrTypeParameter, data: D): R = visitDeclaration(declaration, data)
fun visitFunction(declaration: IrFunction, data: D): R = visitDeclaration(declaration,
data)
fun visitFunction(declaration: IrFunction, data: D): R = visitDeclaration(declaration, data)
fun visitConstructor(declaration: IrConstructor, data: D): R =
visitFunction(declaration, data)
fun visitConstructor(declaration: IrConstructor, data: D): R = visitFunction(declaration, data)
fun visitEnumEntry(declaration: IrEnumEntry, data: D): R =
visitDeclaration(declaration, data)
fun visitEnumEntry(declaration: IrEnumEntry, data: D): R = visitDeclaration(declaration, data)
fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): R =
visitDeclaration(declaration, data)
fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): R = visitDeclaration(declaration, data)
fun visitField(declaration: IrField, data: D): R = visitDeclaration(declaration, data)
fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): R =
visitDeclaration(declaration, data)
fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): R = visitDeclaration(declaration, data)
fun visitModuleFragment(declaration: IrModuleFragment, data: D): R =
visitElement(declaration, data)
fun visitModuleFragment(declaration: IrModuleFragment, data: D): R = visitElement(declaration, data)
fun visitProperty(declaration: IrProperty, data: D): R = visitDeclaration(declaration,
data)
fun visitProperty(declaration: IrProperty, data: D): R = visitDeclaration(declaration, data)
fun visitScript(declaration: IrScript, data: D): R = visitDeclaration(declaration,
data)
fun visitScript(declaration: IrScript, data: D): R = visitDeclaration(declaration, data)
fun visitSimpleFunction(declaration: IrSimpleFunction, data: D): R =
visitFunction(declaration, data)
fun visitSimpleFunction(declaration: IrSimpleFunction, data: D): R = visitFunction(declaration, data)
fun visitTypeAlias(declaration: IrTypeAlias, data: D): R =
visitDeclaration(declaration, data)
fun visitTypeAlias(declaration: IrTypeAlias, data: D): R = visitDeclaration(declaration, data)
fun visitVariable(declaration: IrVariable, data: D): R = visitDeclaration(declaration,
data)
fun visitVariable(declaration: IrVariable, data: D): R = visitDeclaration(declaration, data)
fun visitPackageFragment(declaration: IrPackageFragment, data: D): R =
visitElement(declaration, data)
fun visitPackageFragment(declaration: IrPackageFragment, data: D): R = visitElement(declaration, data)
fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: D): R =
visitPackageFragment(declaration, data)
fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: D): R = visitPackageFragment(declaration, data)
fun visitFile(declaration: IrFile, data: D): R = visitPackageFragment(declaration,
data)
fun visitFile(declaration: IrFile, data: D): R = visitPackageFragment(declaration, data)
fun visitExpression(expression: IrExpression, data: D): R = visitElement(expression,
data)
fun visitExpression(expression: IrExpression, data: D): R = visitElement(expression, data)
fun visitBody(body: IrBody, data: D): R = visitElement(body, data)
@@ -162,38 +64,27 @@ interface IrElementVisitor<out R, in D> {
fun visitBlockBody(body: IrBlockBody, data: D): R = visitBody(body, data)
fun visitDeclarationReference(expression: IrDeclarationReference, data: D): R =
visitExpression(expression, data)
fun visitDeclarationReference(expression: IrDeclarationReference, data: D): R = visitExpression(expression, data)
fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): R =
visitDeclarationReference(expression, data)
fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): R = visitDeclarationReference(expression, data)
fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): R =
visitMemberAccess(expression, data)
fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): R = visitMemberAccess(expression, data)
fun visitConstructorCall(expression: IrConstructorCall, data: D): R =
visitFunctionAccess(expression, data)
fun visitConstructorCall(expression: IrConstructorCall, data: D): R = visitFunctionAccess(expression, data)
fun visitSingletonReference(expression: IrGetSingletonValue, data: D): R =
visitDeclarationReference(expression, data)
fun visitSingletonReference(expression: IrGetSingletonValue, data: D): R = visitDeclarationReference(expression, data)
fun visitGetObjectValue(expression: IrGetObjectValue, data: D): R =
visitSingletonReference(expression, data)
fun visitGetObjectValue(expression: IrGetObjectValue, data: D): R = visitSingletonReference(expression, data)
fun visitGetEnumValue(expression: IrGetEnumValue, data: D): R =
visitSingletonReference(expression, data)
fun visitGetEnumValue(expression: IrGetEnumValue, data: D): R = visitSingletonReference(expression, data)
fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): R =
visitDeclarationReference(expression, data)
fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): R = visitDeclarationReference(expression, data)
fun visitContainerExpression(expression: IrContainerExpression, data: D): R =
visitExpression(expression, data)
fun visitContainerExpression(expression: IrContainerExpression, data: D): R = visitExpression(expression, data)
fun visitBlock(expression: IrBlock, data: D): R = visitContainerExpression(expression,
data)
fun visitBlock(expression: IrBlock, data: D): R = visitContainerExpression(expression, data)
fun visitComposite(expression: IrComposite, data: D): R =
visitContainerExpression(expression, data)
fun visitComposite(expression: IrComposite, data: D): R = visitContainerExpression(expression, data)
fun visitSyntheticBody(body: IrSyntheticBody, data: D): R = visitBody(body, data)
@@ -205,73 +96,51 @@ interface IrElementVisitor<out R, in D> {
fun visitCall(expression: IrCall, data: D): R = visitFunctionAccess(expression, data)
fun visitCallableReference(expression: IrCallableReference<*>, data: D): R =
visitMemberAccess(expression, data)
fun visitCallableReference(expression: IrCallableReference<*>, data: D): R = visitMemberAccess(expression, data)
fun visitFunctionReference(expression: IrFunctionReference, data: D): R =
visitCallableReference(expression, data)
fun visitFunctionReference(expression: IrFunctionReference, data: D): R = visitCallableReference(expression, data)
fun visitPropertyReference(expression: IrPropertyReference, data: D): R =
visitCallableReference(expression, data)
fun visitPropertyReference(expression: IrPropertyReference, data: D): R = visitCallableReference(expression, data)
fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference,
data: D): R = visitCallableReference(expression, data)
fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: D): R = visitCallableReference(expression, data)
fun visitClassReference(expression: IrClassReference, data: D): R =
visitDeclarationReference(expression, data)
fun visitClassReference(expression: IrClassReference, data: D): R = visitDeclarationReference(expression, data)
fun visitConst(expression: IrConst<*>, data: D): R = visitExpression(expression, data)
fun visitConstantValue(expression: IrConstantValue, data: D): R =
visitExpression(expression, data)
fun visitConstantValue(expression: IrConstantValue, data: D): R = visitExpression(expression, data)
fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): R =
visitConstantValue(expression, data)
fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): R = visitConstantValue(expression, data)
fun visitConstantObject(expression: IrConstantObject, data: D): R =
visitConstantValue(expression, data)
fun visitConstantObject(expression: IrConstantObject, data: D): R = visitConstantValue(expression, data)
fun visitConstantArray(expression: IrConstantArray, data: D): R =
visitConstantValue(expression, data)
fun visitConstantArray(expression: IrConstantArray, data: D): R = visitConstantValue(expression, data)
fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: D): R
= visitFunctionAccess(expression, data)
fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: D): R = visitFunctionAccess(expression, data)
fun visitDynamicExpression(expression: IrDynamicExpression, data: D): R =
visitExpression(expression, data)
fun visitDynamicExpression(expression: IrDynamicExpression, data: D): R = visitExpression(expression, data)
fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D): R
= visitDynamicExpression(expression, data)
fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D): R = visitDynamicExpression(expression, data)
fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D): R =
visitDynamicExpression(expression, data)
fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D): R = visitDynamicExpression(expression, data)
fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): R =
visitFunctionAccess(expression, data)
fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): R = visitFunctionAccess(expression, data)
fun visitErrorExpression(expression: IrErrorExpression, data: D): R =
visitExpression(expression, data)
fun visitErrorExpression(expression: IrErrorExpression, data: D): R = visitExpression(expression, data)
fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): R =
visitErrorExpression(expression, data)
fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): R = visitErrorExpression(expression, data)
fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): R =
visitDeclarationReference(expression, data)
fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): R = visitDeclarationReference(expression, data)
fun visitGetField(expression: IrGetField, data: D): R = visitFieldAccess(expression,
data)
fun visitGetField(expression: IrGetField, data: D): R = visitFieldAccess(expression, data)
fun visitSetField(expression: IrSetField, data: D): R = visitFieldAccess(expression,
data)
fun visitSetField(expression: IrSetField, data: D): R = visitFieldAccess(expression, data)
fun visitFunctionExpression(expression: IrFunctionExpression, data: D): R =
visitExpression(expression, data)
fun visitFunctionExpression(expression: IrFunctionExpression, data: D): R = visitExpression(expression, data)
fun visitGetClass(expression: IrGetClass, data: D): R = visitExpression(expression,
data)
fun visitGetClass(expression: IrGetClass, data: D): R = visitExpression(expression, data)
fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: D): R =
visitExpression(expression, data)
fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: D): R = visitExpression(expression, data)
fun visitLoop(loop: IrLoop, data: D): R = visitExpression(loop, data)
@@ -281,14 +150,11 @@ interface IrElementVisitor<out R, in D> {
fun visitReturn(expression: IrReturn, data: D): R = visitExpression(expression, data)
fun visitStringConcatenation(expression: IrStringConcatenation, data: D): R =
visitExpression(expression, data)
fun visitStringConcatenation(expression: IrStringConcatenation, data: D): R = visitExpression(expression, data)
fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): R =
visitExpression(expression, data)
fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): R = visitExpression(expression, data)
fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): R =
visitExpression(expression, data)
fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): R = visitExpression(expression, data)
fun visitThrow(expression: IrThrow, data: D): R = visitExpression(expression, data)
@@ -296,22 +162,17 @@ interface IrElementVisitor<out R, in D> {
fun visitCatch(aCatch: IrCatch, data: D): R = visitElement(aCatch, data)
fun visitTypeOperator(expression: IrTypeOperatorCall, data: D): R =
visitExpression(expression, data)
fun visitTypeOperator(expression: IrTypeOperatorCall, data: D): R = visitExpression(expression, data)
fun visitValueAccess(expression: IrValueAccessExpression, data: D): R =
visitDeclarationReference(expression, data)
fun visitValueAccess(expression: IrValueAccessExpression, data: D): R = visitDeclarationReference(expression, data)
fun visitGetValue(expression: IrGetValue, data: D): R = visitValueAccess(expression,
data)
fun visitGetValue(expression: IrGetValue, data: D): R = visitValueAccess(expression, data)
fun visitSetValue(expression: IrSetValue, data: D): R = visitValueAccess(expression,
data)
fun visitSetValue(expression: IrSetValue, data: D): R = visitValueAccess(expression, data)
fun visitVararg(expression: IrVararg, data: D): R = visitExpression(expression, data)
fun visitSpreadElement(spread: IrSpreadElement, data: D): R = visitElement(spread,
data)
fun visitSpreadElement(spread: IrSpreadElement, data: D): R = visitElement(spread, data)
fun visitWhen(expression: IrWhen, data: D): R = visitExpression(expression, data)
compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt
+498 -342
View File
File diff suppressed because it is too large Load Diff
compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrTypeTransformer.kt
+8 -31
View File
@@ -10,34 +10,15 @@ package org.jetbrains.kotlin.ir.visitors
import org.jetbrains.kotlin.ir.IrElement
import org.jetbrains.kotlin.ir.IrStatement
import org.jetbrains.kotlin.ir.declarations.IrClass
import org.jetbrains.kotlin.ir.declarations.IrField
import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty
import org.jetbrains.kotlin.ir.declarations.IrScript
import org.jetbrains.kotlin.ir.declarations.IrTypeAlias
import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
import org.jetbrains.kotlin.ir.declarations.IrValueParameter
import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.expressions.IrClassReference
import org.jetbrains.kotlin.ir.expressions.IrConstantObject
import org.jetbrains.kotlin.ir.expressions.IrConstantValue
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall
import org.jetbrains.kotlin.ir.expressions.IrVararg
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.types.IrType
interface IrTypeTransformer<in D> : IrElementTransformer<D> {
fun <Type : IrType?> transformType(
container: IrElement,
type: Type,
data: D,
): Type
fun <Type : IrType?> transformType(container: IrElement, type: Type, data: D): Type
override fun visitValueParameter(declaration: IrValueParameter, data: D): IrStatement {
declaration.varargElementType = transformType(declaration, declaration.varargElementType,
data)
declaration.varargElementType = transformType(declaration, declaration.varargElementType, data)
declaration.type = transformType(declaration, declaration.type, data)
return super.visitValueParameter(declaration, data)
}
@@ -65,8 +46,7 @@ interface IrTypeTransformer<in D> : IrElementTransformer<D> {
return super.visitField(declaration, data)
}
override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty,
data: D): IrStatement {
override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): IrStatement {
declaration.type = transformType(declaration, declaration.type, data)
return super.visitLocalDelegatedProperty(declaration, data)
}
@@ -91,8 +71,7 @@ interface IrTypeTransformer<in D> : IrElementTransformer<D> {
return super.visitExpression(expression, data)
}
override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D):
IrElement {
override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): IrElement {
(0 until expression.typeArgumentsCount).forEach {
expression.getTypeArgument(it)?.let { type ->
expression.putTypeArgument(it, transformType(expression, type, data))
@@ -106,11 +85,9 @@ interface IrTypeTransformer<in D> : IrElementTransformer<D> {
return super.visitClassReference(expression, data)
}
override fun visitConstantObject(expression: IrConstantObject, data: D):
IrConstantValue {
override fun visitConstantObject(expression: IrConstantObject, data: D): IrConstantValue {
for (i in 0 until expression.typeArguments.size) {
expression.typeArguments[i] = transformType(expression, expression.typeArguments[i],
data)
expression.typeArguments[i] = transformType(expression, expression.typeArguments[i], data)
}
return super.visitConstantObject(expression, data)
}
compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/CommonTypes.kt
+2
View File
@@ -27,7 +27,9 @@ object Packages {
val elementBaseType = type(tree, "IrElementBase", TypeKind.Class)
val statementOriginType = type(exprs, "IrStatementOrigin")
val elementVisitorType = type(visitors, "IrElementVisitor")
val elementVisitorVoidType = type(visitors, "IrElementVisitorVoid")
val elementTransformerType = type(visitors, "IrElementTransformer")
val typeTransformerType = type(visitors, "IrTypeTransformer")
val mutableAnnotationContainerType = type(declarations, "IrMutableAnnotationContainer")
val irTypeType = type(types, "IrType")
compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Model.kt
+3 -3
View File
@@ -37,7 +37,7 @@ class Element(
override val args: Map<NamedTypeParameterRef, TypeRef>
get() = emptyMap()
var visitorParent: ElementRef? = null
override var parentInVisitor: Element? = null
var transformerReturnType: Element? = null
override var kind: ImplementationKind? = when (config.typeKind) {
@@ -54,8 +54,8 @@ class Element(
override var walkableChildren: List<Field> = emptyList()
override val transformableChildren get() = walkableChildren.filter { it.transformable }
val visitFunName = "visit" + (config.visitorName ?: name).replaceFirstChar(Char::uppercaseChar)
val visitorParam = config.visitorParam ?: config.category.defaultVisitorParam
override val visitFunctionName = "visit" + (config.visitorName ?: name).replaceFirstChar(Char::uppercaseChar)
override val visitorParameterName = config.visitorParam ?: config.category.defaultVisitorParam
override var hasAcceptMethod = config.accept
compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Transformations.kt
+2 -2
View File
@@ -123,7 +123,7 @@ private fun replaceElementRefs(config: Config, mapping: Map<ElementConfig, Eleme
.partitionIsInstance<TypeRef, ElementRef>()
el.elementParents = elParents.takeIf { it.isNotEmpty() || el == rootEl.element } ?: listOf(rootEl)
el.otherParents = otherParents.castAll<ClassRef<*>>().toMutableList()
el.visitorParent = ec.visitorParent?.let(::transform) as GenericElementRef<Element, Field>?
el.parentInVisitor = (ec.visitorParent?.let(::transform) as GenericElementRef<Element, Field>?)?.element
el.transformerReturnType = (ec.transformerReturnType?.let(::transform) as GenericElementRef<Element, Field>?)?.element
for (field in el.fields) {
@@ -154,7 +154,7 @@ private fun markLeaves(elements: List<Element>) {
for (el in leaves) {
el.isLeaf = true
if (el.visitorParent != null) {
if (el.parentInVisitor != null) {
el.hasAcceptMethod = true
}
}
compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Elements.kt
+1 -1
View File
@@ -97,7 +97,7 @@ fun printElements(generationPath: File, model: Model) = sequence {
.also(::addParameter)
returns(r)
if (!isRootElement) {
addStatement("return %N.%N(this, %N)", visitorParam, element.visitFunName, dataParam)
addStatement("return %N.%N(this, %N)", visitorParam, element.visitFunctionName, dataParam)
}
if (isRootElement) {
addKdoc(
compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/VisitorsAndTransformers.kt
+199 -155
View File
@@ -5,139 +5,144 @@
package org.jetbrains.kotlin.ir.generator.print
import com.squareup.kotlinpoet.*
import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
import org.jetbrains.kotlin.generators.tree.printer.GeneratedFile
import org.jetbrains.kotlin.ir.generator.IrTree
import org.jetbrains.kotlin.ir.generator.VISITOR_PACKAGE
import org.jetbrains.kotlin.ir.generator.irTypeType
import org.jetbrains.kotlin.generators.tree.*
import org.jetbrains.kotlin.generators.tree.printer.*
import org.jetbrains.kotlin.ir.generator.*
import org.jetbrains.kotlin.ir.generator.model.*
import org.jetbrains.kotlin.types.Variance
import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly
import org.jetbrains.kotlin.utils.SmartPrinter
import org.jetbrains.kotlin.utils.withIndent
import java.io.File
private val visitorTypeName = ClassName(VISITOR_PACKAGE, "IrElementVisitor")
private val visitorVoidTypeName = ClassName(VISITOR_PACKAGE, "IrElementVisitorVoid")
private val transformerTypeName = ClassName(VISITOR_PACKAGE, "IrElementTransformer")
private val typeTransformerTypeName = ClassName(VISITOR_PACKAGE, "IrTypeTransformer")
private fun printVisitorCommon(
generationPath: File,
model: Model,
visitorType: ClassRef<*>,
makePrinter: (SmartPrinter, ClassRef<*>) -> AbstractVisitorPrinter<Element, Field>,
): GeneratedFile =
printGeneratedType(generationPath, TREE_GENERATOR_README, visitorType.packageName, visitorType.simpleName) {
println()
makePrinter(this, visitorType).printVisitor(model.elements)
}
fun printVisitor(generationPath: File, model: Model): GeneratedFile {
val visitorType = TypeSpec.interfaceBuilder(visitorTypeName).apply {
val r = TypeVariableName("R", KModifier.OUT)
val d = TypeVariableName("D", KModifier.IN)
addTypeVariable(r)
addTypeVariable(d)
private open class VisitorPrinter(printer: SmartPrinter, override val visitorType: ClassRef<*>) :
AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
addParameter(element.visitorParam, element.toPoetStarParameterized())
addParameter("data", d)
returns(r)
}
override val visitorTypeParameters: List<TypeVariable>
get() = listOf(resultTypeVariable, dataTypeVariable)
addFunction(buildVisitFun(model.rootElement).addModifiers(KModifier.ABSTRACT).build())
override val visitorDataType: TypeRef
get() = dataTypeVariable
for (element in model.elements) {
element.visitorParent?.let { parent ->
addFunction(buildVisitFun(element).apply {
addStatement("return ${parent.element.visitFunName}(${element.visitorParam}, data)")
}.build())
}
}
}.build()
override fun visitMethodReturnType(element: Element) = resultTypeVariable
return printTypeCommon(generationPath, visitorTypeName.packageName, visitorType)
override val visitorSuperType: ClassRef<PositionTypeParameterRef>?
get() = null
override val allowTypeParametersInVisitorMethods: Boolean
get() = false
}
fun printVisitorVoid(generationPath: File, model: Model): GeneratedFile {
val dataType = NOTHING.copy(nullable = true)
fun printVisitor(generationPath: File, model: Model) = printVisitorCommon(generationPath, model, elementVisitorType, ::VisitorPrinter)
val visitorType = TypeSpec.interfaceBuilder(visitorVoidTypeName).apply {
addSuperinterface(visitorTypeName.parameterizedBy(UNIT, dataType))
private class VisitorVoidPrinter(
printer: SmartPrinter,
override val visitorType: ClassRef<*>,
) : AbstractVisitorVoidPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
addModifiers(KModifier.OVERRIDE)
addParameter(element.visitorParam, element.toPoetStarParameterized())
addParameter("data", dataType)
addStatement("return ${element.visitFunName}(${element.visitorParam})")
}
override val visitorSuperClass: ClassRef<PositionTypeParameterRef>
get() = elementVisitorType
fun buildVisitVoidFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
addParameter(element.visitorParam, element.toPoetStarParameterized())
}
override val allowTypeParametersInVisitorMethods: Boolean
get() = false
addFunction(buildVisitFun(model.rootElement).build())
addFunction(buildVisitVoidFun(model.rootElement).build())
override val useAbstractMethodForRootElement: Boolean
get() = false
for (element in model.elements) {
element.visitorParent?.let { parent ->
addFunction(buildVisitFun(element).build())
addFunction(buildVisitVoidFun(element).apply {
addStatement("return ${parent.element.visitFunName}(${element.visitorParam})")
}.build())
}
}
}.build()
return printTypeCommon(generationPath, visitorVoidTypeName.packageName, visitorType)
override val overriddenVisitMethodsAreFinal: Boolean
get() = false
}
fun printTransformer(generationPath: File, model: Model): GeneratedFile {
val visitorType = TypeSpec.interfaceBuilder(transformerTypeName).apply {
val d = TypeVariableName("D", KModifier.IN)
addTypeVariable(d)
fun printVisitorVoid(generationPath: File, model: Model) =
printVisitorCommon(generationPath, model, elementVisitorVoidType, ::VisitorVoidPrinter)
addSuperinterface(visitorTypeName.parameterizedBy(model.rootElement.toPoetStarParameterized(), d))
private class TransformerPrinter(
printer: SmartPrinter,
override val visitorType: ClassRef<*>,
val rootElement: Element,
) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
addModifiers(KModifier.OVERRIDE)
addParameter(element.visitorParam, element.toPoetStarParameterized())
addParameter("data", d)
}
override val visitorSuperType: ClassRef<PositionTypeParameterRef>
get() = elementVisitorType.withArgs(rootElement, dataTypeVariable)
for (element in model.elements) {
val returnType = element.getTransformExplicitType()
if (element.transformByChildren) {
addFunction(buildVisitFun(element).apply {
addStatement("${element.visitorParam}.transformChildren(this, data)")
addStatement("return ${element.visitorParam}")
returns(returnType.toPoetStarParameterized())
}.build())
} else {
element.visitorParent?.let { parent ->
addFunction(buildVisitFun(element).apply {
addStatement("return ${parent.element.visitFunName}(${element.visitorParam}, data)")
returns(returnType.toPoetStarParameterized())
}.build())
}
}
}
}.build()
override val visitorTypeParameters: List<TypeVariable>
get() = listOf(dataTypeVariable)
return printTypeCommon(generationPath, transformerTypeName.packageName, visitorType)
}
override val visitorDataType: TypeRef
get() = dataTypeVariable
fun printTypeVisitor(generationPath: File, model: Model): GeneratedFile {
val transformTypeFunName = "transformType"
override fun visitMethodReturnType(element: Element) = element.getTransformExplicitType()
fun FunSpec.Builder.addVisitTypeStatement(element: Element, field: Field) {
val visitorParam = element.visitorParam
val access = "$visitorParam.${field.name}"
when (field) {
is SingleField -> addStatement("$access = $transformTypeFunName($visitorParam, $access, data)")
is ListField -> {
if (field.isMutable) {
addStatement("$access = $access.map { $transformTypeFunName($visitorParam, it, data) }")
override val allowTypeParametersInVisitorMethods: Boolean
get() = false
context(ImportCollector)
override fun printMethodsForElement(element: Element) {
printer.run {
val parent = element.parentInVisitor
if (element.transformByChildren || parent != null) {
println()
printVisitMethodDeclaration(
element = element,
override = true,
)
if (element.transformByChildren) {
println(" {")
withIndent {
println(element.visitorParameterName, ".transformChildren(this, data)")
println("return ", element.visitorParameterName)
}
println("}")
} else {
beginControlFlow("for (i in 0 until $access.size)")
addStatement("$access[i] = $transformTypeFunName($visitorParam, $access[i], data)")
endControlFlow()
println(" =")
withIndent {
println(parent!!.visitFunctionName, "(", element.visitorParameterName, ", data)")
}
}
}
}
}
}
fun Element.getFieldsWithIrTypeType(insideParent: Boolean = false): List<Field> {
fun printTransformer(generationPath: File, model: Model): GeneratedFile =
printVisitorCommon(generationPath, model, elementTransformerType) { printer, visitorType ->
TransformerPrinter(printer, visitorType, model.rootElement)
}
private class TypeTransformerPrinter(
printer: SmartPrinter,
override val visitorType: ClassRef<*>,
val rootElement: Element,
) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
override val visitorSuperType: ClassRef<PositionTypeParameterRef>
get() = elementTransformerType.withArgs(dataTypeVariable)
override val visitorTypeParameters: List<TypeVariable>
get() = listOf(dataTypeVariable)
override val visitorDataType: TypeRef
get() = dataTypeVariable
override fun visitMethodReturnType(element: Element) = element.getTransformExplicitType()
override val allowTypeParametersInVisitorMethods: Boolean
get() = false
private fun Element.getFieldsWithIrTypeType(insideParent: Boolean = false): List<Field> {
val parentsFields = elementParents.flatMap { it.element.getFieldsWithIrTypeType(insideParent = true) }
if (insideParent && this.visitorParent != null) {
if (insideParent && this.parentInVisitor != null) {
return parentsFields
}
@@ -153,71 +158,110 @@ fun printTypeVisitor(generationPath: File, model: Model): GeneratedFile {
return irTypeFields + parentsFields
}
val visitorType = TypeSpec.interfaceBuilder(typeTransformerTypeName).apply {
val d = TypeVariableName("D", KModifier.IN)
addTypeVariable(d)
addSuperinterface(transformerTypeName.parameterizedBy(d))
context(ImportCollector)
override fun SmartPrinter.printAdditionalMethods() {
val typeTP = TypeVariable("Type", listOf(irTypeType.copy(nullable = true)), Variance.INVARIANT)
printFunctionDeclaration(
name = "transformType",
parameters = listOf(
FunctionParameter("container", rootElement),
FunctionParameter("type", typeTP),
FunctionParameter("data", visitorDataType)
),
returnType = typeTP,
typeParameters = listOf(typeTP),
)
println()
}
val abstractVisitFun = FunSpec.builder(transformTypeFunName).apply {
val poetNullableIrType = irTypeType.toPoet().copy(nullable = true)
val typeVariable = TypeVariableName("Type", poetNullableIrType)
addTypeVariable(typeVariable)
addParameter("container", model.rootElement.toPoet())
addParameter("type", typeVariable)
addParameter("data", d)
returns(typeVariable)
}
addFunction(abstractVisitFun.addModifiers(KModifier.ABSTRACT).build())
context(ImportCollector)
override fun printMethodsForElement(element: Element) {
val irTypeFields = element.getFieldsWithIrTypeType()
if (irTypeFields.isEmpty()) return
if (element.parentInVisitor == null) return
printer.run {
println()
val visitorParam = element.visitorParameterName
printVisitMethodDeclaration(
element = element,
override = true,
)
fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
addModifiers(KModifier.OVERRIDE)
addParameter(element.visitorParam, element.toPoetStarParameterized())
addParameter("data", d)
}
fun addVisitTypeStatement(field: Field) {
val access = "$visitorParam.${field.name}"
when (field) {
is SingleField -> println(access, " = ", "transformType(", visitorParam, ", ", access, ", data)")
is ListField -> {
if (field.isMutable) {
println(access, " = ", access, ".map { transformType(", visitorParam, ", it, data) }")
} else {
println("for (i in 0 until ", access, ".size) {")
withIndent {
println(access, "[i] = transformType(", visitorParam, ", ", access, "[i], data)")
}
println("}")
}
}
}
}
for (element in model.elements) {
val irTypeFields = element.getFieldsWithIrTypeType()
if (irTypeFields.isEmpty()) continue
val returnType = element.getTransformExplicitType()
element.visitorParent?.let { _ ->
addFunction(buildVisitFun(element).apply {
returns(returnType.toPoetStarParameterized())
val visitorParam = element.visitorParam
when (element.name) {
IrTree.memberAccessExpression.name -> {
if (irTypeFields.singleOrNull()?.name != "typeArguments") {
error(
"""`Ir${IrTree.memberAccessExpression.name.capitalizeAsciiOnly()}` has unexpected fields with `IrType` type.
|Please adjust logic of `${typeTransformerTypeName.simpleName}`'s generation.""".trimMargin()
println(" {")
withIndent {
when (element.name) {
IrTree.memberAccessExpression.name -> {
if (irTypeFields.singleOrNull()?.name != "typeArguments") {
error(
"""`Ir${IrTree.memberAccessExpression.name.capitalizeAsciiOnly()}` has unexpected fields with `IrType` type.
|Please adjust logic of `${visitorType.simpleName}`'s generation.""".trimMargin()
)
}
println("(0 until ", visitorParam, ".typeArgumentsCount).forEach {")
withIndent {
println(visitorParam, ".getTypeArgument(it)?.let { type ->")
withIndent {
println(
visitorParam,
".putTypeArgument(it, transformType(",
visitorParam,
", type, data))"
)
}
beginControlFlow("(0 until $visitorParam.typeArgumentsCount).forEach {")
beginControlFlow("$visitorParam.getTypeArgument(it)?.let { type ->")
addStatement("expression.putTypeArgument(it, $transformTypeFunName($visitorParam, type, data))")
endControlFlow()
endControlFlow()
println("}")
}
IrTree.`class`.name -> {
beginControlFlow("$visitorParam.valueClassRepresentation?.mapUnderlyingType {")
addStatement("$transformTypeFunName($visitorParam, it, data)")
endControlFlow()
irTypeFields.forEach { addVisitTypeStatement(element, it) }
}
else -> irTypeFields.forEach { addVisitTypeStatement(element, it) }
println("}")
}
addStatement("return super.${element.visitFunName}($visitorParam, data)")
}.build())
IrTree.`class`.name -> {
println(visitorParam, ".valueClassRepresentation?.mapUnderlyingType {")
withIndent {
println("transformType(", visitorParam, ", it, data)")
}
println("}")
irTypeFields.forEach(::addVisitTypeStatement)
}
else -> {
irTypeFields.forEach(::addVisitTypeStatement)
}
}
println(
"return super.",
element.visitFunctionName,
"(",
visitorParam,
", data)"
)
}
println("}")
}
}.build()
return printTypeCommon(generationPath, typeTransformerTypeName.packageName, visitorType)
}
}
fun printTypeVisitor(generationPath: File, model: Model): GeneratedFile =
printVisitorCommon(generationPath, model, typeTransformerType) { printer, visitorType ->
TypeTransformerPrinter(printer, visitorType, model.rootElement)
}
private fun Element.getTransformExplicitType(): Element {
return generateSequence(this) { it.visitorParent?.element }
return generateSequence(this) { it.parentInVisitor?.element }
.firstNotNullOfOrNull {
when {
it.transformByChildren -> it.transformerReturnType ?: it