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

FIR: Get rid of CompositeTransformResult

Browse Source
This commit is contained in:
Ilya Chernikov
2021-04-09 16:38:44 +02:00
parent 00df2c4a9e
commit dfd5e80ce9
52 changed files with 913 additions and 1108 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/FirElement.kt
+2 -3
View File
@@ -5,7 +5,6 @@
package org.jetbrains.kotlin.fir
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.*
/*
@@ -25,8 +24,8 @@ interface FirElement {
fun acceptChildren(visitor: FirVisitorVoid) = acceptChildren(visitor, null)
@Suppress("UNCHECKED_CAST")
fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): CompositeTransformResult<E> =
accept(visitor, data) as CompositeTransformResult<E>
fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): E =
accept(visitor, data) as E
fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt
+251 -252
View File
File diff suppressed because it is too large Load Diff
compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt
-45
View File
@@ -1,45 +0,0 @@
/*
* Copyright 2000-2018 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.fir.visitors
import org.jetbrains.kotlin.fir.FirElement
sealed class CompositeTransformResult<out T : Any> {
class Single<out T : Any>(val _single: T) : CompositeTransformResult<T>()
class Multiple<out T : Any>(val _list: List<T>) : CompositeTransformResult<T>()
companion object {
fun <T : Any> empty() = Multiple(emptyList<T>())
fun <T : Any> single(t: T) = Single(t)
fun <T : Any> many(l: List<T>) = Multiple(l)
}
@Suppress("UNCHECKED_CAST")
val list: List<T>
get() = when (this) {
is Multiple<*> -> _list as List<T>
else -> error("!")
}
@Suppress("UNCHECKED_CAST")
val single: T
get() = when (this) {
is Single<*> -> _single as T
else -> error("!")
}
val isSingle
get() = this is Single<*>
val isEmpty
get() = this is Multiple<*> && this.list.isEmpty()
}
@Suppress("NOTHING_TO_INLINE")
inline fun <T : FirElement> T.compose() = CompositeTransformResult.single(this)
compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt
+21 -21
View File
@@ -12,94 +12,94 @@ import org.jetbrains.kotlin.fir.references.FirReference
import org.jetbrains.kotlin.fir.types.*
abstract class FirDefaultTransformer<D> : FirTransformer<D>() {
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: D): FirTypeRef {
return transformTypeRef(implicitTypeRef, data)
}
override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: D): FirTypeRef {
return transformTypeRef(resolvedTypeRef, data)
}
override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): FirTypeRef {
return transformResolvedTypeRef(errorTypeRef, data)
}
override fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): CompositeTransformResult<FirTypeRef> {
override fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: D): FirTypeRef {
return transformTypeRef(typeRefWithNullability, data)
}
override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: D): FirTypeRef {
return transformTypeRefWithNullability(dynamicTypeRef, data)
}
override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: D): FirTypeRef {
return transformTypeRefWithNullability(functionTypeRef, data)
}
override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult<FirTypeRef> {
override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: D): FirTypeRef {
return transformTypeRefWithNullability(userTypeRef, data)
}
override fun transformCallableReferenceAccess(
callableReferenceAccess: FirCallableReferenceAccess,
data: D
): CompositeTransformResult<FirStatement> {
): FirStatement {
return transformQualifiedAccessExpression(callableReferenceAccess, data)
}
override fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult<FirStatement> {
override fun transformComponentCall(componentCall: FirComponentCall, data: D): FirStatement {
return transformFunctionCall(componentCall, data)
}
override fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult<FirStatement> {
override fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): FirStatement {
return transformJump(returnExpression, data)
}
override fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult<FirStatement> {
override fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): FirStatement {
return transformJump(continueExpression, data)
}
override fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult<FirStatement> {
override fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): FirStatement {
return transformJump(breakExpression, data)
}
override fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
override fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: D): FirStatement {
return transformWrappedArgumentExpression(lambdaArgumentExpression, data)
}
override fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
override fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: D): FirStatement {
return transformWrappedArgumentExpression(spreadArgumentExpression, data)
}
override fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
override fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): FirStatement {
return transformWrappedArgumentExpression(namedArgumentExpression, data)
}
override fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult<FirStatement> {
override fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): FirStatement {
return transformExpression(errorExpression, data)
}
override fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): CompositeTransformResult<FirStatement> {
override fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): FirStatement {
return transformLoop(errorLoop, data)
}
override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): CompositeTransformResult<FirReference> {
override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: D): FirReference {
return transformNamedReference(errorNamedReference, data)
}
override fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): CompositeTransformResult<FirStatement> {
override fun transformErrorFunction(errorFunction: FirErrorFunction, data: D): FirStatement {
return transformFunction(errorFunction, data)
}
override fun transformErrorResolvedQualifier(
errorResolvedQualifier: FirErrorResolvedQualifier,
data: D
): CompositeTransformResult<FirStatement> {
): FirStatement {
return transformResolvedQualifier(errorResolvedQualifier, data)
}
override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): CompositeTransformResult<FirStatement> {
override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: D): FirStatement {
return transformFunctionCall(implicitInvokeCall, data)
}
}
compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformerUtil.kt
+3 -16
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirPureAbstractElement
fun <T : FirElement, D> T.transformSingle(transformer: FirTransformer<D>, data: D): T {
return (this as FirPureAbstractElement).transform<T, D>(transformer, data).single
return (this as FirPureAbstractElement).transform<T, D>(transformer, data)
}
fun <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirTransformer<D>, data: D) {
@@ -17,20 +17,7 @@ fun <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirTransfor
while (iterator.hasNext()) {
val next = iterator.next() as FirPureAbstractElement
val result = next.transform<T, D>(transformer, data)
if (result.isSingle) {
iterator.set(result.single)
} else {
val resultIterator = result.list.listIterator()
if (!resultIterator.hasNext()) {
iterator.remove()
} else {
iterator.set(resultIterator.next())
}
while (resultIterator.hasNext()) {
iterator.add(resultIterator.next())
}
}
iterator.set(result)
}
}
@@ -48,7 +35,7 @@ inline fun <T : FirElement, D> MutableList<T>.transformInplace(transformer: FirT
is TransformData.Data<D> -> data.value
TransformData.Nothing -> continue
}
val result = next.transform<T, D>(transformer, data).single
val result = next.transform<T, D>(transformer, data)
iterator.set(result)
}
}
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt
-1
View File
@@ -60,7 +60,6 @@ val implicitStringTypeRefType = generatedType("types.impl", "FirImplicitStringTy
val implicitUnitTypeRefType = generatedType("types.impl", "FirImplicitUnitTypeRef")
val resolvePhaseType = type("fir.declarations", "FirResolvePhase")
val stubReferenceType = generatedType("references.impl", "FirStubReference")
val compositeTransformResultType = type("fir.visitors", "CompositeTransformResult")
val abstractFirBasedSymbolType = type("fir.symbols", "AbstractFirBasedSymbol")
val backingFieldSymbolType = type("fir.symbols.impl", "FirBackingFieldSymbol")
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt
+2 -2
View File
@@ -133,9 +133,9 @@ fun SmartPrinter.printElement(element: Element) {
println("fun acceptChildren(visitor: FirVisitorVoid) = acceptChildren(visitor, null)")
println()
println("@Suppress(\"UNCHECKED_CAST\")")
println("fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): CompositeTransformResult<E> =")
println("fun <E : FirElement, D> transform(visitor: FirTransformer<D>, data: D): E =")
withIndent {
println("accept(visitor, data) as CompositeTransformResult<E>")
println("accept(visitor, data) as E")
}
println()
println("fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement")
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt
+6 -8
View File
@@ -5,7 +5,6 @@
package org.jetbrains.kotlin.fir.tree.generator.printer
import org.jetbrains.kotlin.fir.tree.generator.compositeTransformResultType
import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
import org.jetbrains.kotlin.fir.tree.generator.model.Element
import org.jetbrains.kotlin.util.SmartPrinter
@@ -22,14 +21,13 @@ fun printTransformer(elements: List<Element>, generationPath: File): GeneratedFi
println("package $VISITOR_PACKAGE")
println()
elements.forEach { println("import ${it.fullQualifiedName}") }
println("import ${compositeTransformResultType.fullQualifiedName}")
println()
printGeneratedMessage()
println("abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirElement>, D>() {")
println("abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {")
println()
withIndent {
println("abstract fun <E : FirElement> transformElement(element: E, data: D): CompositeTransformResult<E>")
println("abstract fun <E : FirElement> transformElement(element: E, data: D): E")
println()
for (element in elements) {
if (element == AbstractFirTreeBuilder.baseFirElement) continue
@@ -37,8 +35,8 @@ fun printTransformer(elements: List<Element>, generationPath: File): GeneratedFi
print("open fun ")
element.typeParameters.takeIf { it.isNotBlank() }?.let { print(it) }
println(
"transform${element.name}($varName: ${element.typeWithArguments}, data: D): CompositeTransformResult<${element.transformerType
.typeWithArguments}>${element.multipleUpperBoundsList()}{",
"transform${element.name}($varName: ${element.typeWithArguments}, data: D): ${element.transformerType
.typeWithArguments}${element.multipleUpperBoundsList()}{",
)
withIndent {
println("return transformElement($varName, data)")
@@ -53,8 +51,8 @@ fun printTransformer(elements: List<Element>, generationPath: File): GeneratedFi
element.typeParameters.takeIf { it.isNotBlank() }?.let { print(it) }
println(
"visit${element.name}($varName: ${element.typeWithArguments}, data: D): CompositeTransformResult<${element.transformerType
.typeWithArguments}>${element.multipleUpperBoundsList()}{",
"visit${element.name}($varName: ${element.typeWithArguments}, data: D): ${element.transformerType
.typeWithArguments}${element.multipleUpperBoundsList()}{",
)
withIndent {
println("return transform${element.name}($varName, data)")
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/utils.kt
-5
View File
@@ -5,7 +5,6 @@
package org.jetbrains.kotlin.fir.tree.generator.printer
import org.jetbrains.kotlin.fir.tree.generator.compositeTransformResultType
import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
import org.jetbrains.kotlin.fir.tree.generator.firImplementationDetailType
import org.jetbrains.kotlin.fir.tree.generator.model.*
@@ -52,10 +51,6 @@ fun Implementation.collectImports(base: List<String> = emptyList(), kind: Import
fun Element.collectImports(): List<String> {
val baseTypes = parents.mapTo(mutableListOf()) { it.fullQualifiedName }
baseTypes += parentsArguments.values.flatMap { it.values }.mapNotNull { it.fullQualifiedName }
val isBaseFirElement = this == AbstractFirTreeBuilder.baseFirElement
if (isBaseFirElement) {
baseTypes += compositeTransformResultType.fullQualifiedName!!
}
if (needPureAbstractElement) {
baseTypes += pureAbstractElementType.fullQualifiedName!!
}