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

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt

@@ -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 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt

@@ -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

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirStringConcatenationCall.kt

@@ -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

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Main.kt

@@ -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)

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt

@@ -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 parentRefs = element.parentRefs
-        val superTypesStrings = elementParents.map {
+        if (parentRefs.isNotEmpty()) {
-            // TODO: Factor out
+            print(
-            var result = it.element.type
+                parentRefs.sortedBy { it.typeKind }.joinToString(prefix = " : ") { parent ->
-            if (it.args.isNotEmpty()) {
+                    parent.typeWithArguments + parent.inheritanceClauseParenthesis()
-                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(", ")
                 }
-            }
+            )
-            print(superTypesStrings.joinToString(", "),)
         }
         print(multipleUpperBoundsList())
         println(" {")

compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Model.kt

@@ -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()

compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Transformations.kt

@@ -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) {

compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Elements.kt

@@ -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

compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Types.kt

@@ -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
-    }

generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractElement.kt

@@ -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

generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/ImplementationKindOwner.kt

@@ -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 }

generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/TypeRef.kt

@@ -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 -> ""
+    }
+}

generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/addPureAbstractElement.kt

@@ -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)
+        }
+    }
+}