[FIR/IR generator] Factor out adding pure abstract element as parent

2023-09-19 13:14:25 +02:00
parent 5798021e4b
commit 04c5ac0eb6
13 changed files with 49 additions and 44 deletions
@@ -72,7 +72,7 @@ abstract class ExpressionCheckers {
    @CheckersComponentInternal internal val allGetClassCallCheckers: Set<FirGetClassCallChecker> by lazy { getClassCallCheckers + basicExpressionCheckers + callCheckers }
    @CheckersComponentInternal internal val allSafeCallExpressionCheckers: Set<FirSafeCallExpressionChecker> by lazy { safeCallExpressionCheckers + basicExpressionCheckers }
    @CheckersComponentInternal internal val allEqualityOperatorCallCheckers: Set<FirEqualityOperatorCallChecker> by lazy { equalityOperatorCallCheckers + basicExpressionCheckers + callCheckers }
-    @CheckersComponentInternal internal val allStringConcatenationCallCheckers: Set<FirStringConcatenationCallChecker> by lazy { stringConcatenationCallCheckers + callCheckers + basicExpressionCheckers }
+    @CheckersComponentInternal internal val allStringConcatenationCallCheckers: Set<FirStringConcatenationCallChecker> by lazy { stringConcatenationCallCheckers + basicExpressionCheckers + callCheckers }
    @CheckersComponentInternal internal val allTypeOperatorCallCheckers: Set<FirTypeOperatorCallChecker> by lazy { typeOperatorCallCheckers + basicExpressionCheckers + callCheckers }
    @CheckersComponentInternal internal val allResolvedQualifierCheckers: Set<FirResolvedQualifierChecker> by lazy { resolvedQualifierCheckers + basicExpressionCheckers }
    @CheckersComponentInternal internal val allConstExpressionCheckers: Set<FirConstExpressionChecker> by lazy { constExpressionCheckers + basicExpressionCheckers }
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.fir.declarations.ResolveStateAccess

-abstract class FirTypeParameter : FirTypeParameterRef, FirDeclaration() {
+abstract class FirTypeParameter : FirDeclaration(), FirTypeParameterRef {
    abstract override val source: KtSourceElement?
    abstract override val moduleData: FirModuleData
    abstract override val origin: FirDeclarationOrigin
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.fir.expressions.UnresolvedExpressionTypeAccess

-abstract class FirStringConcatenationCall : FirCall, FirExpression() {
+abstract class FirStringConcatenationCall : FirExpression(), FirCall {
    abstract override val source: KtSourceElement?
    abstract override val annotations: List<FirAnnotation>
    abstract override val argumentList: FirArgumentList
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.tree.generator
 import org.jetbrains.kotlin.fir.tree.generator.printer.generateElements
 import org.jetbrains.kotlin.fir.tree.generator.util.configureInterfacesAndAbstractClasses
 import org.jetbrains.kotlin.fir.tree.generator.util.detectBaseTransformerTypes
+import org.jetbrains.kotlin.generators.tree.addPureAbstractElement
 import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil
 import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil.collectPreviouslyGeneratedFiles
 import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil.removeExtraFilesFromPreviousGeneration
@@ -22,6 +23,7 @@ fun main(args: Array<String>) {
    detectBaseTransformerTypes(FirTreeBuilder)
    ImplementationConfigurator.configureImplementations()
    configureInterfacesAndAbstractClasses(FirTreeBuilder)
+    addPureAbstractElement(FirTreeBuilder.elements, pureAbstractElementType)
    BuilderConfigurator.configureBuilders()
    val previouslyGeneratedFiles = collectPreviouslyGeneratedFiles(generationPath)
    val generatedFiles = generateElements(FirTreeBuilder, generationPath)
@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.tree.generator.printer

 import org.jetbrains.kotlin.fir.tree.generator.model.Element
 import org.jetbrains.kotlin.fir.tree.generator.model.Field
-import org.jetbrains.kotlin.fir.tree.generator.pureAbstractElementType
 import org.jetbrains.kotlin.fir.tree.generator.util.get
 import org.jetbrains.kotlin.generators.tree.*
 import org.jetbrains.kotlin.generators.tree.printer.*
@@ -42,25 +41,13 @@ fun SmartPrinter.printElement(element: Element) {

        print("${kind!!.title} $type")
        print(typeParameters())
-        val needPureAbstractElement = this.needPureAbstractElement
-        val superTypesStrings = elementParents.map {
-            // TODO: Factor out
-            var result = it.element.type
-            if (it.args.isNotEmpty()) {
-                result += it.args.values.joinToString(", ", "<", ">") { it.typeWithArguments }
-            }
-            result + it.element.kind.braces()
-        } + otherParents.map { it.type }
-
-        if (superTypesStrings.isNotEmpty() || needPureAbstractElement) {
-            print(" : ")
-            if (needPureAbstractElement) {
-                print("${pureAbstractElementType.type}()")
-                if (superTypesStrings.isNotEmpty()) {
-                    print(", ")
+        val parentRefs = element.parentRefs
+        if (parentRefs.isNotEmpty()) {
+            print(
+                parentRefs.sortedBy { it.typeKind }.joinToString(prefix = " : ") { parent ->
+                    parent.typeWithArguments + parent.inheritanceClauseParenthesis()
                }
-            }
-            print(superTypesStrings.joinToString(", "),)
+            )
        }
        print(multipleUpperBoundsList())
        println(" {")
@@ -23,7 +23,7 @@ class Element(
    val additionalFactoryMethodParameters: MutableList<Field>,
 ) : AbstractElement<Element, Field>() {
    override var elementParents: List<ElementRef> = emptyList()
-    override var otherParents: List<ClassRef<*>> = emptyList()
+    override var otherParents: MutableList<ClassRef<*>> = mutableListOf()

    override val allFields: List<Field>
        get() = fields.toList()
@@ -44,7 +44,7 @@ fun config2model(config: Config): Model {

    val rootElement = replaceElementRefs(config, ec2el)
    configureInterfacesAndAbstractClasses(elements)
-    addAbstractElement(elements)
+    addPureAbstractElement(elements, elementBaseType)
    markLeaves(elements)
    configureDescriptorApiAnnotation(elements)
    processFieldOverrides(elements)
@@ -120,7 +120,7 @@ private fun replaceElementRefs(config: Config, mapping: Map<ElementConfig, Eleme
            .map { transform(it) }
            .partitionIsInstance<TypeRef, ElementRef>()
        el.elementParents = elParents.takeIf { it.isNotEmpty() || el == rootEl.element } ?: listOf(rootEl)
-        el.otherParents = otherParents.castAll<ClassRef<*>>().toList()
+        el.otherParents = otherParents.castAll<ClassRef<*>>().toMutableList()
        el.visitorParent = ec.visitorParent?.let(::transform) as GenericElementRef<Element, Field>?
        el.transformerReturnType = (ec.transformerReturnType?.let(::transform) as GenericElementRef<Element, Field>?)?.element

@@ -158,14 +158,6 @@ private fun markLeaves(elements: List<Element>) {
    }
 }

-private fun addAbstractElement(elements: List<Element>) {
-    for (el in elements) {
-        if (el.needPureAbstractElement) {
-            el.otherParents += elementBaseType
-        }
-    }
-}
-
 private fun configureDescriptorApiAnnotation(elements: List<Element>) {
    for (el in elements) {
        for (field in el.fields) {
@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.ir.generator.elementTransformerType
 import org.jetbrains.kotlin.ir.generator.elementVisitorType
 import org.jetbrains.kotlin.ir.generator.model.*
 import org.jetbrains.kotlin.generators.tree.TypeRefWithNullability
+import org.jetbrains.kotlin.generators.tree.typeKind
 import org.jetbrains.kotlin.ir.generator.util.tryParameterizedBy
 import java.io.File
 import org.jetbrains.kotlin.generators.tree.ElementRef as GenericElementRef
@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.ir.generator.model.Element.Companion.elementName2typ
 import org.jetbrains.kotlin.ir.generator.util.*
 import org.jetbrains.kotlin.types.Variance
 import  org.jetbrains.kotlin.generators.tree.ElementRef as GenericElementRef
-import  org.jetbrains.kotlin.generators.tree.ElementOrRef as GenericElementOrRef

 fun Element.toPoet() = ClassName(packageName, typeName)
 fun Element.toPoetSelfParameterized() = toPoet().parameterizedByIfAny(poetTypeVariables)
@@ -67,8 +66,3 @@ fun TypeVariable.toPoet() = TypeVariableName(
    }
 )

-val ClassOrElementRef.typeKind: TypeKind
-    get() = when (this) {
-        is GenericElementOrRef<*, *> -> element.kind!!.typeKind
-        is ClassRef<*> -> kind
-    }
@@ -22,7 +22,7 @@ abstract class AbstractElement<Element, Field> : ElementOrRef<Element, Field>, F

    abstract val elementParents: List<ElementRef<Element, Field>>

-    abstract val otherParents: List<ClassRef<*>>
+    abstract val otherParents: MutableList<ClassRef<*>>

    val parentRefs: List<ClassOrElementRef>
        get() = elementParents + otherParents
@@ -9,7 +9,3 @@ interface ImplementationKindOwner : Importable {
    var kind: ImplementationKind?
    val allParents: List<ImplementationKindOwner>
 }
-
-val ImplementationKindOwner.needPureAbstractElement: Boolean
-    get() = !(kind?.isInterface ?: false) &&
-            allParents.none { it.kind == ImplementationKind.AbstractClass || it.kind == ImplementationKind.SealedClass }
@@ -5,6 +5,7 @@

 package org.jetbrains.kotlin.generators.tree

+import org.jetbrains.kotlin.generators.tree.printer.braces
 import org.jetbrains.kotlin.types.Variance
 import java.util.*
 import kotlin.reflect.KClass
@@ -196,3 +197,17 @@ inline fun <reified T : Any> type(vararg args: TypeRef) = T::class.asRef<Positio

 fun type(packageName: String, name: String, kind: TypeKind = TypeKind.Interface) =
    ClassRef<PositionTypeParameterRef>(kind, packageName, name)
+
+val ClassOrElementRef.typeKind: TypeKind
+    get() = when (this) {
+        is ElementOrRef<*, *> -> element.kind!!.typeKind
+        is ClassRef<*> -> kind
+    }
+
+fun ClassOrElementRef.inheritanceClauseParenthesis(): String = when (this) {
+    is ElementOrRef<*, *> -> element.kind.braces()
+    is ClassRef<*> -> when (kind) {
+        TypeKind.Class -> "()"
+        TypeKind.Interface -> ""
+    }
+}
@@ -0,0 +1,18 @@
+/*
+ * 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
+
+val ImplementationKindOwner.needPureAbstractElement: Boolean
+    get() = !(kind?.isInterface ?: false) &&
+            allParents.none { it.kind == ImplementationKind.AbstractClass || it.kind == ImplementationKind.SealedClass }
+
+fun addPureAbstractElement(elements: List<AbstractElement<*, *>>, pureAbstractElement: ClassRef<*>) {
+    for (el in elements) {
+        if (el.needPureAbstractElement) {
+            el.otherParents.add(pureAbstractElement)
+        }
+    }
+}