[FIR/IR generator] Use TypeRef for working with types in fields

- Don't inherit `AbstractField` from `Importable`, because it really
  is not
- Remove the `arguments` and `nullable` properties from `AbstractField`.
  Both properties can be derived from the field's `typeRef`.
- Make `AbstractField`'s `typeRef` property of type
  `TypeRefWithNullability` instead of just `TypeRef`, because fields
  can always be nullable.

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

@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.types.Variance
 // 2) parents
 // 3) fields
 object IrTree : AbstractTreeBuilder() {
-    private fun symbol(type: TypeRef, mutable: Boolean = false): SimpleFieldConfig =
+    private fun symbol(type: TypeRefWithNullability, mutable: Boolean = false): SimpleFieldConfig =
         field("symbol", type, mutable = mutable)
 
     private fun descriptor(typeName: String, nullable: Boolean = false): SimpleFieldConfig =

compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/config/AbstractTreeBuilder.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.ir.generator.config
 
 import org.jetbrains.kotlin.generators.tree.TypeRef
+import org.jetbrains.kotlin.generators.tree.TypeRefWithNullability
 import org.jetbrains.kotlin.generators.tree.TypeVariable
 import org.jetbrains.kotlin.generators.tree.type
 import org.jetbrains.kotlin.types.Variance
@@ -36,7 +37,7 @@ abstract class AbstractTreeBuilder {
 
     protected fun field(
         name: String,
-        type: TypeRef?,
+        type: TypeRefWithNullability?,
         nullable: Boolean = false,
         mutable: Boolean = true,
         isChild: Boolean = false,

compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/config/ConfigModel.kt

@@ -62,6 +62,8 @@ class ElementConfig(
     override fun copy(args: Map<NamedTypeParameterRef, TypeRef>) = ElementConfigRef(this, args, false)
     override fun copy(nullable: Boolean) = ElementConfigRef(this, args, nullable)
 
+    override fun substitute(map: TypeParameterSubstitutionMap): ElementConfig = this
+
     operator fun TypeVariable.unaryPlus() = apply {
         params.add(this)
     }
@@ -78,8 +80,6 @@ class ElementConfig(
     override val type: String
         get() = Element.elementName2typeName(name)
 
-    override fun getTypeWithArguments(notNull: Boolean): String = type
-
     enum class Category(private val packageDir: String, val defaultVisitorParam: String) {
         Expression("expressions", "expression"),
         Declaration("declarations", "declaration"),
@@ -108,8 +108,6 @@ class ElementConfigRef(
 
     override val packageName: String
         get() = element.packageName
-
-    override fun getTypeWithArguments(notNull: Boolean): String = type + generics
 }
 
 sealed class UseFieldAsParameterInIrFactoryStrategy {
@@ -152,7 +150,7 @@ sealed class FieldConfig(
 
 class SimpleFieldConfig(
     name: String,
-    val type: TypeRef?,
+    val type: TypeRefWithNullability?,
     val nullable: Boolean,
     val mutable: Boolean,
     isChildElement: Boolean,

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

@@ -116,7 +116,6 @@ typealias ElementOrRef = GenericElementOrRef<Element, Field>
 sealed class Field(
     config: FieldConfig,
     override val name: String,
-    override val nullable: Boolean,
     override var isMutable: Boolean,
     val isChild: Boolean,
 ) : AbstractField() {
@@ -145,25 +144,17 @@ sealed class Field(
 
     override val isParameter: Boolean
         get() = false
-
-    override val type: String
-        get() = typeRef.type
-    override val packageName: String?
-        get() = typeRef.packageName
-
-    override fun getTypeWithArguments(notNull: Boolean): String = typeRef.getTypeWithArguments(notNull)
 }
 
 class SingleField(
     config: FieldConfig,
     name: String,
-    override var typeRef: TypeRef,
-    nullable: Boolean,
+    override var typeRef: TypeRefWithNullability,
     mutable: Boolean,
     isChild: Boolean,
     override val baseDefaultValue: CodeBlock?,
     override val baseGetter: CodeBlock?,
-) : Field(config, name, nullable, mutable, isChild) {
+) : Field(config, name, mutable, isChild) {
     override val transformable: Boolean
         get() = isMutable
 }
@@ -173,13 +164,12 @@ class ListField(
     name: String,
     var elementType: TypeRef,
     private val listType: ClassRef<PositionTypeParameterRef>,
-    nullable: Boolean,
     mutable: Boolean,
     isChild: Boolean,
     override val transformable: Boolean,
     override val baseDefaultValue: CodeBlock?,
     override val baseGetter: CodeBlock?,
-) : Field(config, name, nullable, mutable, isChild) {
-    override val typeRef: TypeRef
+) : Field(config, name, mutable, isChild) {
+    override val typeRef: TypeRefWithNullability
         get() = listType.withArgs(elementType)
 }

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

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.castAll
 import org.jetbrains.kotlin.utils.addToStdlib.partitionIsInstance
 import org.jetbrains.kotlin.generators.tree.ElementRef as GenericElementRef
 
-private object InferredOverriddenType : TypeRef {
+private object InferredOverriddenType : TypeRefWithNullability {
     override val type: String
         get() = error("not supported")
     override val packageName: String?
@@ -22,6 +22,13 @@ private object InferredOverriddenType : TypeRef {
     override fun getTypeWithArguments(notNull: Boolean): String {
         error("not supported")
     }
+
+    override fun substitute(map: TypeParameterSubstitutionMap) = this
+
+    override val nullable: Boolean
+        get() = false
+
+    override fun copy(nullable: Boolean) = this
 }
 
 data class Model(val elements: List<Element>, val rootElement: Element)
@@ -57,8 +64,7 @@ private fun transformFieldConfig(fc: FieldConfig): Field = when (fc) {
     is SimpleFieldConfig -> SingleField(
         fc,
         fc.name,
-        fc.type ?: InferredOverriddenType,
-        fc.nullable,
+        fc.type?.copy(fc.nullable) ?: InferredOverriddenType,
         fc.mutable,
         fc.isChild,
         fc.baseDefaultValue,
@@ -74,8 +80,7 @@ private fun transformFieldConfig(fc: FieldConfig): Field = when (fc) {
             fc,
             fc.name,
             fc.elementType ?: InferredOverriddenType,
-            listType,
-            fc.nullable,
+            listType.copy(fc.nullable),
             fc.mutability == ListFieldConfig.Mutability.Var,
             fc.isChild,
             fc.mutability != ListFieldConfig.Mutability.Immutable,
@@ -127,7 +132,7 @@ private fun replaceElementRefs(config: Config, mapping: Map<ElementConfig, Eleme
         for (field in el.fields) {
             when (field) {
                 is SingleField -> {
-                    field.typeRef = transform(field.typeRef)
+                    field.typeRef = transform(field.typeRef) as TypeRefWithNullability
                 }
                 is ListField -> {
                     field.elementType = transform(field.elementType)
@@ -186,7 +191,8 @@ private fun processFieldOverrides(elements: List<Element>) {
                             type.takeUnless { it is InferredOverriddenType } ?: overriddenType
                         when (field) {
                             is SingleField -> {
-                                field.typeRef = transformInferredType(field.typeRef, (overriddenField as SingleField).typeRef)
+                                field.typeRef =
+                                    transformInferredType(field.typeRef, (overriddenField as SingleField).typeRef) as TypeRefWithNullability
                             }
                             is ListField -> {
                                 field.elementType = transformInferredType(field.elementType, (overriddenField as ListField).elementType)

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

@@ -235,7 +235,6 @@ fun printElements(generationPath: File, model: Model) = sequence {
                                 val elRef = child.typeRef as GenericElementRef<Element, Field>
                                 if (!elRef.element.hasTransformMethod) {
                                     append(" as %T")
-                                    if (child.nullable) append("?")
                                     args.add(elRef.toPoet())
                                 }
                             }