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
core/util.runtime/src/org/jetbrains/kotlin/utils/addToStdlib.kt
+30
View File
@@ -349,3 +349,33 @@ fun <T, R> Iterable<T>.zipWithNulls(other: Iterable<R>): List<Pair<T?, R?>> {
fun unreachableBranch(argument: Any?): Nothing {
error("This argument should've been processed by previous when branches but it wasn't: $argument")
}
/**
* Calls [appendElement] on [buffer] for all the elements, also appending [separator] between them and using the given [prefix]
* and [postfix] if supplied.
*
* If the collection could be huge, you can specify a non-negative value of [limit], in which case only the first [limit]
* elements will be appended, followed by the [truncated] string (which defaults to "...").
*/
fun <T, A : Appendable> Iterable<T>.joinToWithBuffer(
buffer: A,
separator: CharSequence = ", ",
prefix: CharSequence = "",
postfix: CharSequence = "",
limit: Int = -1,
truncated: CharSequence = "...",
appendElement: A.(T) -> Unit,
): A {
buffer.append(prefix)
var count = 0
for (element in this) {
if (++count > 1) buffer.append(separator)
if (limit < 0 || count <= limit) {
buffer.appendElement(element)
} else break
}
if (limit in 0..<count) buffer.append(truncated)
buffer.append(postfix)
return buffer
}
generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractElement.kt
+15
View File
@@ -38,6 +38,21 @@ abstract class AbstractElement<Element, Field> : ElementOrRef<Element, Field>, F
open val isSealed: Boolean
get() = false
/**
* The name of the method in visitors used to visit this element.
*/
abstract val visitFunctionName: String
/**
* The name of the parameter representing this element in the visitor method used to visit this element.
*/
abstract val visitorParameterName: String
/**
* The default element to visit if the method for visiting this element is not overridden.
*/
abstract val parentInVisitor: Element?
override val allParents: List<Element>
get() = elementParents.map { it.element }
generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorPrinter.kt
+159
View File
@@ -0,0 +1,159 @@
/*
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.generators.tree
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.generators.tree.printer.FunctionParameter
import org.jetbrains.kotlin.generators.tree.printer.multipleUpperBoundsList
import org.jetbrains.kotlin.generators.tree.printer.printFunctionDeclaration
import org.jetbrains.kotlin.generators.tree.printer.typeParameters
import org.jetbrains.kotlin.types.Variance
import org.jetbrains.kotlin.utils.SmartPrinter
import org.jetbrains.kotlin.utils.withIndent
abstract class AbstractVisitorPrinter<Element : AbstractElement<Element, Field>, Field : AbstractField>(
val printer: SmartPrinter,
val visitSuperTypeByDefault: Boolean,
) {
/**
* The visitor type to print.
*/
abstract val visitorType: ClassRef<*>
/**
* The result type parameter of the visitor. All visitor methods return result of this type.
*/
protected val resultTypeVariable = TypeVariable("R", emptyList(), Variance.OUT_VARIANCE)
/**
* The data type parameter of the visitor. ALl visitor methods accept a parameter of this type.
*/
protected val dataTypeVariable = TypeVariable("D", emptyList(), Variance.IN_VARIANCE)
/**
* The type parameters of the visitor class. Void visitors have no type parameters,
* regular visitors usually have [resultTypeVariable] and [dataTypeVariable] here.
*/
abstract val visitorTypeParameters: List<TypeVariable>
abstract val visitorDataType: TypeRef
abstract fun visitMethodReturnType(element: Element): TypeRef
/**
* The superclass for this visitor class.
*/
abstract val visitorSuperType: ClassRef<PositionTypeParameterRef>?
/**
* If `true`, visitor methods for generic tree elements will be parameterized correspondingly.
* Otherwise, type arguments of generic tree elements will be replaced with `*`.
*/
abstract val allowTypeParametersInVisitorMethods: Boolean
/**
* Allows to customize the default element to visit if the method for visiting this [element] is not overridden.
*
* If returns `null`, methods for this element will not be overridden in this visitor class (except the root element).
*/
open fun parentInVisitor(element: Element): Element? = element.parentInVisitor
/**
* Prints a single visitor method declaration, without body.
*/
context(ImportCollector)
protected fun SmartPrinter.printVisitMethodDeclaration(
element: Element,
hasDataParameter: Boolean = true,
modality: Modality? = null,
override: Boolean = false,
) {
val visitorParameterType = ElementRef(
element,
element.params.associateWith { if (allowTypeParametersInVisitorMethods) it else TypeRef.Star }
)
val parameters = buildList {
add(FunctionParameter(element.visitorParameterName, visitorParameterType))
if (hasDataParameter) add(FunctionParameter("data", visitorDataType))
}
printFunctionDeclaration(
name = element.visitFunctionName,
parameters = parameters,
returnType = visitMethodReturnType(element),
typeParameters = if (allowTypeParametersInVisitorMethods) {
element.params
} else {
emptyList()
},
modality = modality,
override = override,
)
}
context(ImportCollector)
protected fun printMethodDeclarationForElement(element: Element, modality: Modality? = null, override: Boolean) {
printer.run {
println()
printVisitMethodDeclaration(
element,
modality = modality,
override = override
)
}
}
context(ImportCollector)
protected open fun printMethodsForElement(element: Element) {
printer.run {
val parentInVisitor = parentInVisitor(element)
if (parentInVisitor == null && !element.isRootElement) return
printMethodDeclarationForElement(
element,
modality = when {
visitorSuperType == null && parentInVisitor == null && visitorType.kind == TypeKind.Class -> Modality.ABSTRACT
visitorSuperType == null && parentInVisitor != null && visitorType.kind == TypeKind.Class -> Modality.OPEN
else -> null
},
override = parentInVisitor != null && visitorSuperType != null,
)
if (parentInVisitor != null) {
print(" = ", parentInVisitor.visitFunctionName, "(", element.visitorParameterName, ", data)")
}
println()
}
}
context(ImportCollector)
protected open fun SmartPrinter.printAdditionalMethods() {
}
context(ImportCollector)
fun printVisitor(elements: List<Element>) {
val visitorType = this.visitorType
printer.run {
when (visitorType.kind) {
TypeKind.Interface -> print("interface ")
TypeKind.Class -> print("abstract class ")
}
print(visitorType.simpleName, visitorTypeParameters.typeParameters())
visitorSuperType?.let {
print(" : ", it.render(), it.inheritanceClauseParenthesis())
}
print(visitorTypeParameters.multipleUpperBoundsList())
println(" {")
withIndent {
printAdditionalMethods()
for (element in elements) {
if (element.isRootElement && visitSuperTypeByDefault) continue
if (visitSuperTypeByDefault && parentInVisitor(element) == null) continue
printMethodsForElement(element)
}
}
println("}")
}
}
}
generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorVoidPrinter.kt
+81
View File
@@ -0,0 +1,81 @@
/*
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.generators.tree
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.utils.SmartPrinter
import org.jetbrains.kotlin.utils.withIndent
abstract class AbstractVisitorVoidPrinter<Element, Field>(
printer: SmartPrinter,
visitSuperTypeByDefault: Boolean,
) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault)
where Element : AbstractElement<Element, Field>,
Field : AbstractField {
final override val visitorTypeParameters: List<TypeVariable>
get() = emptyList()
final override val visitorDataType: TypeRef
get() = StandardTypes.nothing.copy(nullable = true)
override fun visitMethodReturnType(element: Element) = StandardTypes.unit
abstract val visitorSuperClass: ClassRef<PositionTypeParameterRef>
override val visitorSuperType: ClassRef<PositionTypeParameterRef>
get() = if (visitSuperTypeByDefault)
visitorSuperClass
else
visitorSuperClass.withArgs(StandardTypes.unit, visitorDataType)
abstract val useAbstractMethodForRootElement: Boolean
abstract val overriddenVisitMethodsAreFinal: Boolean
context(ImportCollector)
final override fun printMethodsForElement(element: Element) {
val parentInVisitor = parentInVisitor(element)
if (!element.isRootElement && parentInVisitor == null) return
val isAbstractVisitRootElementMethod = element.isRootElement && useAbstractMethodForRootElement
printMethodDeclarationForElement(
element,
modality = Modality.FINAL.takeIf { overriddenVisitMethodsAreFinal },
override = true,
)
fun SmartPrinter.printBody(parentInVisitor: Element?) {
println(" {")
if (parentInVisitor != null) {
withIndent {
println(parentInVisitor.visitFunctionName, "(", element.visitorParameterName, ")")
}
}
println("}")
}
printer.run {
printBody(element)
println()
printVisitMethodDeclaration(
element,
hasDataParameter = false,
modality = when {
element.isRootElement && visitorType.kind == TypeKind.Class -> Modality.ABSTRACT
!element.isRootElement && visitorType.kind == TypeKind.Class -> Modality.OPEN
else -> null
}
)
if (isAbstractVisitRootElementMethod) {
println()
} else {
printBody(parentInVisitor)
}
}
}
}
generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/StandardTypes.kt
+2
View File
@@ -6,6 +6,8 @@
package org.jetbrains.kotlin.generators.tree
object StandardTypes {
val unit = type<Unit>()
val nothing = type("kotlin", "Nothing")
val boolean = type<Boolean>()
val string = type<String>()
val int = type<Int>()
generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/printer/printUtils.kt
+85 -13
View File
@@ -5,14 +5,17 @@
package org.jetbrains.kotlin.generators.tree.printer
import org.jetbrains.kotlin.generators.tree.AbstractElement
import org.jetbrains.kotlin.generators.tree.ImplementationKind
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.generators.tree.*
import org.jetbrains.kotlin.utils.SmartPrinter
import org.jetbrains.kotlin.generators.tree.ImportCollector
import org.jetbrains.kotlin.generators.tree.render
import org.jetbrains.kotlin.utils.SmartPrinter
import org.jetbrains.kotlin.types.Variance
import org.jetbrains.kotlin.utils.addToStdlib.joinToWithBuffer
import org.jetbrains.kotlin.utils.withIndent
/**
* The angle bracket-delimited list of type parameters to print, or empty string if the element has no type parameters.
* The angle bracket-delimited list of type parameters to print, or empty string if the list is empty.
*
* For type parameters that have a single upper bound, also prints that upper bound. If at least one type parameter has multiple upper
* bounds, doesn't print any upper bounds at all. They are expected to be printed in the `where` clause (see [multipleUpperBoundsList]).
@@ -20,10 +23,21 @@ import org.jetbrains.kotlin.utils.SmartPrinter
* @param end The string to add after the closing angle bracket of the type parameter list
*/
context(ImportCollector)
fun AbstractElement<*, *>.typeParameters(end: String = ""): String = params.takeIf { it.isNotEmpty() }
?.joinToString(", ", "<", ">$end") { param ->
param.name + (param.bounds.singleOrNull()?.let { " : ${it.render()}" } ?: "")
} ?: ""
fun List<TypeVariable>.typeParameters(end: String = ""): String = buildString {
if (this@typeParameters.isEmpty()) return@buildString
joinToWithBuffer(this, prefix = "<", postfix = ">") { param ->
if (param.variance != Variance.INVARIANT) {
append(param.variance.label)
append(" ")
}
append(param.name)
param.bounds.singleOrNull()?.let {
append(" : ")
it.renderTo(this)
}
}
append(end)
}
/**
* The `where` clause to print after the class or function declaration if at least one of the element's tye parameters has multiple upper
@@ -32,14 +46,17 @@ fun AbstractElement<*, *>.typeParameters(end: String = ""): String = params.take
* Otherwise, an empty string.
*/
context(ImportCollector)
fun AbstractElement<*, *>.multipleUpperBoundsList(): String {
val paramsWithMultipleUpperBounds = params.filter { it.bounds.size > 1 }.takeIf { it.isNotEmpty() } ?: return ""
fun List<TypeVariable>.multipleUpperBoundsList(): String {
val paramsWithMultipleUpperBounds = filter { it.bounds.size > 1 }.takeIf { it.isNotEmpty() } ?: return ""
return buildString {
append(" where ")
paramsWithMultipleUpperBounds.joinTo(this, separator = ", ") { param ->
param.bounds.joinToString(", ") { bound -> "$param : ${bound.render()}" }
paramsWithMultipleUpperBounds.joinToWithBuffer(this, separator = ", ") { param ->
param.bounds.joinToWithBuffer(this) { bound ->
append(param.name)
append(" : ")
bound.renderTo(this)
}
}
append("")
}
}
@@ -75,3 +92,58 @@ fun AbstractElement<*, *>.extendedKDoc(defaultKDoc: String? = null): String = bu
}
append("Generated from: [${element.propertyName}]")
}
data class FunctionParameter(val name: String, val type: TypeRef, val defaultValue: String? = null) {
context(ImportCollector)
fun render(): String = buildString {
append(name, ": ", type.render())
defaultValue?.let {
append(" = ", it)
}
}
}
context(ImportCollector)
fun SmartPrinter.printFunctionDeclaration(
name: String,
parameters: List<FunctionParameter>,
returnType: TypeRef,
typeParameters: List<TypeVariable> = emptyList(),
modality: Modality? = null,
override: Boolean = false,
allParametersOnSeparateLines: Boolean = false,
) {
when (modality) {
null -> {}
Modality.FINAL -> print("final ")
Modality.OPEN -> print("open ")
Modality.ABSTRACT -> print("abstract ")
Modality.SEALED -> error("Function cannot be sealed")
}
if (override) {
print("override ")
}
print("fun ")
print(typeParameters.typeParameters(end = " "))
print(name, "(")
if (allParametersOnSeparateLines) {
if (parameters.isNotEmpty()) {
println()
withIndent {
for (parameter in parameters) {
print(parameter.render())
println(",")
}
}
}
} else {
print(parameters.joinToString { it.render() })
}
print(")")
if (returnType != StandardTypes.unit) {
print(": ", returnType.render())
}
print(typeParameters.multipleUpperBoundsList())
}