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

[FIR] Don't generate replace and transform in implementations with kind = Interface

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2019-10-15 15:16:46 +03:00
parent f86f582922
commit 2ec305b34e
16 changed files with 206 additions and 337 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt
+4
View File
@@ -67,6 +67,10 @@ class FirJavaClass internal constructor(
supertypesComputationStatus = newSupertypesComputationStatus
}
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
resolvePhase = newResolvePhase
}
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
declarations.forEach { it.accept(visitor, data) }
annotations.forEach { it.accept(visitor, data) }
compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/Modifier.kt
+8
View File
@@ -20,6 +20,8 @@ import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PARAMETER_MO
import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PLATFORM_MODIFIER
import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PROPERTY_MODIFIER
import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VISIBILITY_MODIFIER
import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.FirVisitor
class Modifier(
override val psi: PsiElement? = null,
@@ -155,4 +157,10 @@ class Modifier(
fun hasActual(): Boolean {
return platformModifiers.contains(PlatformModifier.ACTUAL) || platformModifiers.contains(PlatformModifier.IMPL)
}
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
return this
}
}
compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeModifier.kt
+8
View File
@@ -9,6 +9,8 @@ import com.intellij.lang.LighterASTNode
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.FirVisitor
import org.jetbrains.kotlin.lexer.KtTokens
class TypeModifier(
@@ -26,4 +28,10 @@ class TypeModifier(
fun hasNoAnnotations(): Boolean {
return annotations.isEmpty()
}
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
return this
}
}
compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeParameterModifier.kt
+8
View File
@@ -11,6 +11,8 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.REIFICATION_MODIFIER
import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VARIANCE_MODIFIER
import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.FirVisitor
import org.jetbrains.kotlin.types.Variance
class TypeParameterModifier(
@@ -40,4 +42,10 @@ class TypeParameterModifier(
fun hasReified(): Boolean {
return reificationModifier == ReificationModifier.REIFIED
}
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
return this
}
}
compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeProjectionModifier.kt
+8
View File
@@ -10,6 +10,8 @@ import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VARIANCE_MODIFIER
import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.FirVisitor
import org.jetbrains.kotlin.types.Variance
class TypeProjectionModifier(
@@ -32,4 +34,10 @@ class TypeProjectionModifier(
else -> Variance.INVARIANT
}
}
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
return this
}
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableClass.kt
+3 -19
View File
@@ -29,25 +29,9 @@ interface FirModifiableClass : FirClass, FirAbstractAnnotatedElement {
override val superTypeRefs: MutableList<FirTypeRef>
override val declarations: MutableList<FirDeclaration>
override val annotations: MutableList<FirAnnotationCall>
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
superTypeRefs.forEach { it.accept(visitor, data) }
declarations.forEach { it.accept(visitor, data) }
annotations.forEach { it.accept(visitor, data) }
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableClass
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableClass {
superTypeRefs.transformInplace(transformer, data)
declarations.transformInplace(transformer, data)
annotations.transformInplace(transformer, data)
return this
}
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
resolvePhase = newResolvePhase
}
override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>) {
superTypeRefs.clear()
superTypeRefs.addAll(newSuperTypeRefs)
}
override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableConstructor.kt
+5 -39
View File
@@ -46,47 +46,13 @@ interface FirModifiableConstructor : FirConstructor, FirModifiableTypeParameters
override val symbol: FirConstructorSymbol
override var delegatedConstructor: FirDelegatedConstructorCall?
override val isPrimary: Boolean
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
returnTypeRef.accept(visitor, data)
receiverTypeRef?.accept(visitor, data)
controlFlowGraphReference.accept(visitor, data)
typeParameters.forEach { it.accept(visitor, data) }
valueParameters.forEach { it.accept(visitor, data) }
body?.accept(visitor, data)
status.accept(visitor, data)
annotations.forEach { it.accept(visitor, data) }
delegatedConstructor?.accept(visitor, data)
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableConstructor
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableConstructor {
transformReturnTypeRef(transformer, data)
receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
transformControlFlowGraphReference(transformer, data)
typeParameters.transformInplace(transformer, data)
transformValueParameters(transformer, data)
body = body?.transformSingle(transformer, data)
status = status.transformSingle(transformer, data)
annotations.transformInplace(transformer, data)
delegatedConstructor = delegatedConstructor?.transformSingle(transformer, data)
return this
}
override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableConstructor
override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableConstructor {
returnTypeRef = returnTypeRef.transformSingle(transformer, data)
return this
}
override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirModifiableConstructor
override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirModifiableConstructor {
controlFlowGraphReference = controlFlowGraphReference.transformSingle(transformer, data)
return this
}
override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirModifiableConstructor
override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirModifiableConstructor {
valueParameters.transformInplace(transformer, data)
return this
}
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
resolvePhase = newResolvePhase
}
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableFunction.kt
+5 -35
View File
@@ -37,43 +37,13 @@ interface FirModifiableFunction<F : FirFunction<F>> : FirFunction<F>, FirAbstra
override val symbol: FirFunctionSymbol<F>
override val valueParameters: MutableList<FirValueParameter>
override var body: FirBlock?
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
annotations.forEach { it.accept(visitor, data) }
returnTypeRef.accept(visitor, data)
receiverTypeRef?.accept(visitor, data)
controlFlowGraphReference.accept(visitor, data)
typeParameters.forEach { it.accept(visitor, data) }
valueParameters.forEach { it.accept(visitor, data) }
body?.accept(visitor, data)
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F>
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F> {
annotations.transformInplace(transformer, data)
transformReturnTypeRef(transformer, data)
receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
transformControlFlowGraphReference(transformer, data)
typeParameters.transformInplace(transformer, data)
transformValueParameters(transformer, data)
body = body?.transformSingle(transformer, data)
return this
}
override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F>
override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F> {
returnTypeRef = returnTypeRef.transformSingle(transformer, data)
return this
}
override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F>
override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F> {
controlFlowGraphReference = controlFlowGraphReference.transformSingle(transformer, data)
return this
}
override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F>
override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F> {
valueParameters.transformInplace(transformer, data)
return this
}
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
resolvePhase = newResolvePhase
}
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableTypeParametersOwner.kt
+1 -8
View File
@@ -18,12 +18,5 @@ import org.jetbrains.kotlin.fir.visitors.*
interface FirModifiableTypeParametersOwner : FirTypeParametersOwner {
override val psi: PsiElement?
override val typeParameters: MutableList<FirTypeParameter>
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
typeParameters.forEach { it.accept(visitor, data) }
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableTypeParametersOwner {
typeParameters.transformInplace(transformer, data)
return this
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableTypeParametersOwner
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableVariable.kt
+6 -39
View File
@@ -40,48 +40,15 @@ interface FirModifiableVariable<F : FirVariable<F>> : FirVariable<F>, FirAbstra
override var getter: FirPropertyAccessor?
override var setter: FirPropertyAccessor?
override val annotations: MutableList<FirAnnotationCall>
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
returnTypeRef.accept(visitor, data)
receiverTypeRef?.accept(visitor, data)
initializer?.accept(visitor, data)
delegate?.accept(visitor, data)
getter?.accept(visitor, data)
setter?.accept(visitor, data)
annotations.forEach { it.accept(visitor, data) }
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F>
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F> {
transformReturnTypeRef(transformer, data)
transformGetter(transformer, data)
transformSetter(transformer, data)
transformOtherChildren(transformer, data)
return this
}
override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F>
override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F> {
returnTypeRef = returnTypeRef.transformSingle(transformer, data)
return this
}
override fun <D> transformGetter(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F>
override fun <D> transformGetter(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F> {
getter = getter?.transformSingle(transformer, data)
return this
}
override fun <D> transformSetter(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F>
override fun <D> transformSetter(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F> {
setter = setter?.transformSingle(transformer, data)
return this
}
override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F>
override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F> {
receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
initializer = initializer?.transformSingle(transformer, data)
delegate = delegate?.transformSingle(transformer, data)
annotations.transformInplace(transformer, data)
return this
}
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
resolvePhase = newResolvePhase
}
override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractLoop.kt
+4 -26
View File
@@ -25,33 +25,11 @@ interface FirAbstractLoop : FirLoop, FirAbstractAnnotatedElement {
override var block: FirBlock
override var condition: FirExpression
override var label: FirLabel?
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
annotations.forEach { it.accept(visitor, data) }
block.accept(visitor, data)
condition.accept(visitor, data)
label?.accept(visitor, data)
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoop
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoop {
transformBlock(transformer, data)
transformCondition(transformer, data)
transformOtherChildren(transformer, data)
return this
}
override fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirAbstractLoop
override fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirAbstractLoop {
block = block.transformSingle(transformer, data)
return this
}
override fun <D> transformCondition(transformer: FirTransformer<D>, data: D): FirAbstractLoop
override fun <D> transformCondition(transformer: FirTransformer<D>, data: D): FirAbstractLoop {
condition = condition.transformSingle(transformer, data)
return this
}
override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoop {
annotations.transformInplace(transformer, data)
label = label?.transformSingle(transformer, data)
return this
}
override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoop
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractLoopJump.kt
+2 -13
View File
@@ -25,18 +25,7 @@ interface FirAbstractLoopJump : FirLoopJump, FirAbstractAnnotatedElement {
override var typeRef: FirTypeRef
override val annotations: MutableList<FirAnnotationCall>
override var target: FirTarget<FirLoop>
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
typeRef.accept(visitor, data)
annotations.forEach { it.accept(visitor, data) }
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoopJump
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoopJump {
typeRef = typeRef.transformSingle(transformer, data)
annotations.transformInplace(transformer, data)
return this
}
override fun replaceTypeRef(newTypeRef: FirTypeRef) {
typeRef = newTypeRef
}
override fun replaceTypeRef(newTypeRef: FirTypeRef)
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallWithArgumentList.kt
+2 -14
View File
@@ -21,19 +21,7 @@ interface FirCallWithArgumentList : FirCall, FirAbstractAnnotatedElement {
override val psi: PsiElement?
override val annotations: MutableList<FirAnnotationCall>
override val arguments: MutableList<FirExpression>
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
annotations.forEach { it.accept(visitor, data) }
arguments.forEach { it.accept(visitor, data) }
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirCallWithArgumentList
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirCallWithArgumentList {
annotations.transformInplace(transformer, data)
transformArguments(transformer, data)
return this
}
override fun <D> transformArguments(transformer: FirTransformer<D>, data: D): FirCallWithArgumentList {
arguments.transformInplace(transformer, data)
return this
}
override fun <D> transformArguments(transformer: FirTransformer<D>, data: D): FirCallWithArgumentList
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirModifiableQualifiedAccess.kt
+4 -34
View File
@@ -24,41 +24,11 @@ interface FirModifiableQualifiedAccess : FirQualifiedAccessWithoutCallee, FirAbs
override var explicitReceiver: FirExpression?
override var dispatchReceiver: FirExpression
override var extensionReceiver: FirExpression
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
annotations.forEach { it.accept(visitor, data) }
explicitReceiver?.accept(visitor, data)
if (dispatchReceiver !== explicitReceiver) {
dispatchReceiver.accept(visitor, data)
}
if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
extensionReceiver.accept(visitor, data)
}
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess {
annotations.transformInplace(transformer, data)
explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
if (dispatchReceiver !== explicitReceiver) {
dispatchReceiver = dispatchReceiver.transformSingle(transformer, data)
}
if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
extensionReceiver = extensionReceiver.transformSingle(transformer, data)
}
return this
}
override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess {
explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
return this
}
override fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
override fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess {
dispatchReceiver = dispatchReceiver.transformSingle(transformer, data)
return this
}
override fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess {
extensionReceiver = extensionReceiver.transformSingle(transformer, data)
return this
}
override fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/impl/FirAbstractAnnotatedElement.kt
+1 -8
View File
@@ -18,12 +18,5 @@ import org.jetbrains.kotlin.fir.visitors.*
interface FirAbstractAnnotatedElement : FirAnnotationContainer {
override val psi: PsiElement?
override val annotations: MutableList<FirAnnotationCall>
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
annotations.forEach { it.accept(visitor, data) }
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
annotations.transformInplace(transformer, data)
return this
}
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement
}
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Printer.kt
+137 -102
View File
@@ -261,7 +261,9 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
val fieldsWithoutDefault = allFields.filter { it.defaultValue == null && !it.isLateinit }
val fieldsWithDefault = allFields.filter { it.defaultValue != null || it.isLateinit }
if (kind != Implementation.Kind.Interface && fieldsWithoutDefault.isNotEmpty()) {
val isInterface = kind == Implementation.Kind.Interface
if (!isInterface && fieldsWithoutDefault.isNotEmpty()) {
println("(")
fieldsWithoutDefault.forEachIndexed { i, field ->
val end = if (i == fieldsWithoutDefault.size - 1) "" else ","
@@ -276,7 +278,7 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
}
println(" {")
if (kind == Implementation.Kind.Interface) {
if (isInterface) {
allFields.forEach { printField(it, isImplementation = true, override = true, end = "") }
} else {
fieldsWithDefault.forEach {
@@ -288,7 +290,7 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
}
element.allFields.filter { it.type.contains("Symbol") }
.takeIf { it.isNotEmpty() && kind != Implementation.Kind.Interface && !element.type.contains("Reference")}
.takeIf { it.isNotEmpty() && !isInterface && !element.type.contains("Reference")}
?.let { symbolFields ->
indent(1)
println("init {")
@@ -301,21 +303,24 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
println()
}
indent(1)
print("override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {")
fun Field.acceptString(): String = "${name}${call()}accept(visitor, data)"
if (!isInterface) {
if (element.allFirFields.isNotEmpty()) {
println()
for (field in allFields.filter { it.isFirType }) {
if (field.withGetter || !field.needAcceptAndTransform) continue
when (field.name) {
"explicitReceiver" -> {
val explicitReceiver = implementation["explicitReceiver"]!!
val dispatchReceiver = implementation["dispatchReceiver"]!!
val extensionReceiver = implementation["extensionReceiver"]!!
println("""
indent(1)
print("override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {")
if (element.allFirFields.isNotEmpty()) {
println()
for (field in allFields.filter { it.isFirType }) {
if (field.withGetter || !field.needAcceptAndTransform) continue
when (field.name) {
"explicitReceiver" -> {
val explicitReceiver = implementation["explicitReceiver"]!!
val dispatchReceiver = implementation["dispatchReceiver"]!!
val extensionReceiver = implementation["extensionReceiver"]!!
println(
"""
| ${explicitReceiver.acceptString()}
| if (dispatchReceiver !== explicitReceiver) {
| ${dispatchReceiver.acceptString()}
@@ -323,115 +328,135 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
| if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
| ${extensionReceiver.acceptString()}
| }
""".trimMargin())
}
"dispatchReceiver", "extensionReceiver", "subjectVariable" -> {}
"companionObject" -> {}
else -> {
if (type == "FirClassImpl" && field.name == "declarations") {
indent(2)
println("(declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.forEach { it.accept(visitor, data) }")
""".trimMargin()
)
}
if (type == "FirWhenExpressionImpl" && field.name == "subject") {
println(
"""
"dispatchReceiver", "extensionReceiver", "subjectVariable" -> {
}
"companionObject" -> {
}
else -> {
if (type == "FirClassImpl" && field.name == "declarations") {
indent(2)
println("(declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.forEach { it.accept(visitor, data) }")
}
if (type == "FirWhenExpressionImpl" && field.name == "subject") {
println(
"""
| if (subjectVariable != null) {
| subjectVariable.accept(visitor, data)
| } else {
| subject?.accept(visitor, data)
| }
""".trimMargin()
)
} else {
indent(2)
when (field.origin) {
is FirField -> {
println(field.acceptString())
}
)
} else {
indent(2)
when (field.origin) {
is FirField -> {
println(field.acceptString())
}
is FieldList -> {
println("${field.name}.forEach { it.accept(visitor, data) }")
}
is FieldList -> {
println("${field.name}.forEach { it.accept(visitor, data) }")
}
else -> throw IllegalStateException()
else -> throw IllegalStateException()
}
}
}
}
}
}
indent()
}
indent()
println("}")
println()
}
println("}")
println()
indent()
println("override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): $typeWithArguments {")
for (field in allFields) {
when {
!field.isMutable || !field.isFirType || field.withGetter || !field.needAcceptAndTransform -> {}
field.name == "explicitReceiver" -> {
val explicitReceiver = implementation["explicitReceiver"]!!
val dispatchReceiver = implementation["dispatchReceiver"]!!
val extensionReceiver = implementation["extensionReceiver"]!!
if (explicitReceiver.isMutable) {
indent(2)
println("explicitReceiver = explicitReceiver${explicitReceiver.call()}transformSingle(transformer, data)")
print("override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): $typeWithArguments")
if (!isInterface) {
println(" {")
for (field in allFields) {
when {
!field.isMutable || !field.isFirType || field.withGetter || !field.needAcceptAndTransform -> {
}
if (dispatchReceiver.isMutable) {
println("""
field.name == "explicitReceiver" -> {
val explicitReceiver = implementation["explicitReceiver"]!!
val dispatchReceiver = implementation["dispatchReceiver"]!!
val extensionReceiver = implementation["extensionReceiver"]!!
if (explicitReceiver.isMutable) {
indent(2)
println("explicitReceiver = explicitReceiver${explicitReceiver.call()}transformSingle(transformer, data)")
}
if (dispatchReceiver.isMutable) {
println(
"""
| if (dispatchReceiver !== explicitReceiver) {
| dispatchReceiver = dispatchReceiver.transformSingle(transformer, data)
| }
""".trimMargin())
}
if (extensionReceiver.isMutable) {
println("""
""".trimMargin()
)
}
if (extensionReceiver.isMutable) {
println(
"""
| if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
| extensionReceiver = extensionReceiver.transformSingle(transformer, data)
| }
""".trimMargin())
""".trimMargin()
)
}
}
field.name in setOf("dispatchReceiver", "extensionReceiver") -> {
}
type == "FirClassImpl" && field.name == "declarations" -> {
indent(2)
println("(declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.transformInplace(transformer, data)")
indent(2)
println("declarations.transformInplace(transformer, data)")
}
field.name == "companionObject" -> {
indent(2)
println("companionObject = declarations.asSequence().filterIsInstance<FirRegularClass>().firstOrNull { it.status.isCompanion }")
}
field.needsSeparateTransform -> {
indent(2)
println("transform${field.name.capitalize()}(transformer, data)")
}
!element.needTransformOtherChildren -> {
indent(2)
field.transform()
}
else -> {
}
}
field.name in setOf("dispatchReceiver", "extensionReceiver") -> {}
type == "FirClassImpl" && field.name == "declarations" -> {
indent(2)
println("(declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.transformInplace(transformer, data)")
indent(2)
println("declarations.transformInplace(transformer, data)")
}
field.name == "companionObject" -> {
indent(2)
println("companionObject = declarations.asSequence().filterIsInstance<FirRegularClass>().firstOrNull { it.status.isCompanion }")
}
field.needsSeparateTransform -> {
indent(2)
println("transform${field.name.capitalize()}(transformer, data)")
}
!element.needTransformOtherChildren -> {
indent(2)
field.transform()
}
else -> {}
}
}
if (element.needTransformOtherChildren) {
if (element.needTransformOtherChildren) {
indent(2)
println("transformOtherChildren(transformer, data)")
}
indent(2)
println("transformOtherChildren(transformer, data)")
println("return this")
indent()
println("}")
} else {
println()
}
indent(2)
println("return this")
indent()
println("}")
for (field in allFields) {
if (!field.needsSeparateTransform) continue
println()
indent()
print("override ${field.transformFunctionDeclaration(typeWithArguments)} {")
println()
print("override ${field.transformFunctionDeclaration(typeWithArguments)}")
if (isInterface) {
println()
continue
}
println(" {")
if (field.isMutable && field.isFirType) {
// TODO: replace with smth normal
if (type == "FirWhenExpressionImpl" && field.name == "subject") {
@@ -456,24 +481,34 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
if (element.needTransformOtherChildren) {
println()
indent()
println("override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): $typeWithArguments {")
for (field in allFields) {
if (!field.isMutable || !field.isFirType || field.name == "subjectVariable") continue
if (!field.needsSeparateTransform) {
indent(2)
field.transform()
print("override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): $typeWithArguments")
if (isInterface) {
println()
} else {
println(" {")
for (field in allFields) {
if (!field.isMutable || !field.isFirType || field.name == "subjectVariable") continue
if (!field.needsSeparateTransform) {
indent(2)
field.transform()
}
}
indent(2)
println("return this")
indent()
println("}")
}
indent(2)
println("return this")
indent()
println("}")
}
for (field in allFields.filter { it.withReplace }) {
println()
indent()
print("override ${field.replaceFunctionDeclaration()} {")
print("override ${field.replaceFunctionDeclaration()}")
if (isInterface) {
println()
continue
}
print(" {")
if (!field.isMutable) {
println("}")
continue