[FIR] Rename FirClassImpl to FirRegularClassImpl

Also rename `buildClassImpl` to `buildRegularClass` and get rid
  of intermediate `AbstractFirRegularClassBuilder`

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/AbstractFirRegularClassBuilder.kt

@@ -1,52 +0,0 @@
-/*
- * Copyright 2010-2020 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.declarations.builder
-
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.builder.FirClassBuilder
-import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterRefsOwnerBuilder
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
-import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
-import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
-import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.visitors.*
-import org.jetbrains.kotlin.name.Name
-
-/*
- * This file was generated automatically
- * DO NOT MODIFY IT MANUALLY
- */
-
-@FirBuilderDsl
-interface AbstractFirRegularClassBuilder : FirClassBuilder, FirTypeParameterRefsOwnerBuilder {
-    abstract override var source: FirSourceElement?
-    abstract override val annotations: MutableList<FirAnnotationCall>
-    abstract override var session: FirSession
-    abstract override var origin: FirDeclarationOrigin
-    abstract override val typeParameters: MutableList<FirTypeParameterRef>
-    abstract override var classKind: ClassKind
-    abstract override val superTypeRefs: MutableList<FirTypeRef>
-    abstract override val declarations: MutableList<FirDeclaration>
-    abstract override var scopeProvider: FirScopeProvider
-    abstract var resolvePhase: FirResolvePhase
-    abstract var status: FirDeclarationStatus
-    abstract var name: Name
-    abstract var symbol: FirRegularClassSymbol
-    abstract var companionObject: FirRegularClass?
-    abstract var hasLazyNestedClassifiers: Boolean
-    abstract var controlFlowGraphReference: FirControlFlowGraphReference
-    override fun build(): FirRegularClass
-}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirRegularClassBuilder.kt

@@ -18,8 +18,9 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.builder.AbstractFirRegularClassBuilder
-import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
+import org.jetbrains.kotlin.fir.declarations.builder.FirClassBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterRefsOwnerBuilder
+import org.jetbrains.kotlin.fir.declarations.impl.FirRegularClassImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.references.impl.FirEmptyControlFlowGraphReference
@@ -35,24 +36,24 @@ import org.jetbrains.kotlin.name.Name
  */
 
 @FirBuilderDsl
-open class FirClassImplBuilder : AbstractFirRegularClassBuilder, FirAnnotationContainerBuilder {
+open class FirRegularClassBuilder : FirClassBuilder, FirTypeParameterRefsOwnerBuilder, FirAnnotationContainerBuilder {
     override var source: FirSourceElement? = null
     override lateinit var session: FirSession
-    override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    open var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
     override lateinit var origin: FirDeclarationOrigin
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf()
-    override lateinit var status: FirDeclarationStatus
+    open lateinit var status: FirDeclarationStatus
     override lateinit var classKind: ClassKind
     override val declarations: MutableList<FirDeclaration> = mutableListOf()
     override lateinit var scopeProvider: FirScopeProvider
-    override lateinit var name: Name
-    override lateinit var symbol: FirRegularClassSymbol
-    override var companionObject: FirRegularClass? = null
+    open lateinit var name: Name
+    open lateinit var symbol: FirRegularClassSymbol
+    open var companionObject: FirRegularClass? = null
     override val superTypeRefs: MutableList<FirTypeRef> = mutableListOf()
 
     override fun build(): FirRegularClass {
-        return FirClassImpl(
+        return FirRegularClassImpl(
             source,
             session,
             resolvePhase,
@@ -70,26 +71,12 @@ open class FirClassImplBuilder : AbstractFirRegularClassBuilder, FirAnnotationCo
         )
     }
 
-
-    @Deprecated("Modification of 'hasLazyNestedClassifiers' has no impact for FirClassImplBuilder", level = DeprecationLevel.HIDDEN)
-    override var hasLazyNestedClassifiers: Boolean
-        get() = throw IllegalStateException()
-        set(value) {
-            throw IllegalStateException()
-        }
-
-    @Deprecated("Modification of 'controlFlowGraphReference' has no impact for FirClassImplBuilder", level = DeprecationLevel.HIDDEN)
-    override var controlFlowGraphReference: FirControlFlowGraphReference
-        get() = throw IllegalStateException()
-        set(value) {
-            throw IllegalStateException()
-        }
 }
 
 @OptIn(ExperimentalContracts::class)
-inline fun buildClassImpl(init: FirClassImplBuilder.() -> Unit): FirRegularClass {
+inline fun buildRegularClass(init: FirRegularClassBuilder.() -> Unit): FirRegularClass {
     contract {
         callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
     }
-    return FirClassImplBuilder().apply(init).build()
+    return FirRegularClassBuilder().apply(init).build()
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirRegularClassImpl.kt

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-internal class FirClassImpl(
+internal class FirRegularClassImpl(
     override val source: FirSourceElement?,
     override val session: FirSession,
     override var resolvePhase: FirResolvePhase,
@@ -62,7 +62,7 @@ internal class FirClassImpl(
         controlFlowGraphReference.accept(visitor, data)
     }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirClassImpl {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirRegularClassImpl {
         transformAnnotations(transformer, data)
         typeParameters.transformInplace(transformer, data)
         transformStatus(transformer, data)
@@ -73,32 +73,32 @@ internal class FirClassImpl(
         return this
     }
 
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirClassImpl {
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirRegularClassImpl {
         annotations.transformInplace(transformer, data)
         return this
     }
 
-    override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirClassImpl {
+    override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirRegularClassImpl {
         status = status.transformSingle(transformer, data)
         return this
     }
 
-    override fun <D> transformDeclarations(transformer: FirTransformer<D>, data: D): FirClassImpl {
+    override fun <D> transformDeclarations(transformer: FirTransformer<D>, data: D): FirRegularClassImpl {
         declarations.transformInplace(transformer, data)
         return this
     }
 
-    override fun <D> transformCompanionObject(transformer: FirTransformer<D>, data: D): FirClassImpl {
+    override fun <D> transformCompanionObject(transformer: FirTransformer<D>, data: D): FirRegularClassImpl {
         companionObject = companionObject?.transformSingle(transformer, data)
         return this
     }
 
-    override fun <D> transformSuperTypeRefs(transformer: FirTransformer<D>, data: D): FirClassImpl {
+    override fun <D> transformSuperTypeRefs(transformer: FirTransformer<D>, data: D): FirRegularClassImpl {
         superTypeRefs.transformInplace(transformer, data)
         return this
     }
 
-    override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirClassImpl {
+    override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirRegularClassImpl {
         controlFlowGraphReference = controlFlowGraphReference.transformSingle(transformer, data)
         return this
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/EnumClassUtils.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.builder.AbstractFirRegularClassBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.FirRegularClassBuilder
 import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
@@ -29,7 +29,7 @@ private val ENUM_VALUES = Name.identifier("values")
 private val ENUM_VALUE_OF = Name.identifier("valueOf")
 private val VALUE = Name.identifier("value")
 
-fun AbstractFirRegularClassBuilder.generateValuesFunction(session: FirSession, packageFqName: FqName, classFqName: FqName) {
+fun FirRegularClassBuilder.generateValuesFunction(session: FirSession, packageFqName: FqName, classFqName: FqName) {
     declarations += buildSimpleFunction {
         source = this@generateValuesFunction.source
         origin = FirDeclarationOrigin.Source
@@ -54,7 +54,7 @@ fun AbstractFirRegularClassBuilder.generateValuesFunction(session: FirSession, p
     }
 }
 
-fun AbstractFirRegularClassBuilder.generateValueOfFunction(session: FirSession, packageFqName: FqName, classFqName: FqName) {
+fun FirRegularClassBuilder.generateValueOfFunction(session: FirSession, packageFqName: FqName, classFqName: FqName) {
     declarations += buildSimpleFunction {
         source = this@generateValueOfFunction.source
         origin = FirDeclarationOrigin.Source

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt

@@ -7,9 +7,9 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.declarations.builder.AbstractFirRegularClassBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.FirRegularClassBuilder
 import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterBuilder
-import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirRegularClassImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirFileImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -65,14 +65,14 @@ inline val FirPropertyAccessor.allowsToHaveFakeOverride: Boolean
 
 inline val FirRegularClass.isLocal get() = symbol.classId.isLocal
 
-fun AbstractFirRegularClassBuilder.addDeclaration(declaration: FirDeclaration) {
+fun FirRegularClassBuilder.addDeclaration(declaration: FirDeclaration) {
     declarations += declaration
     if (companionObject == null && declaration is FirRegularClass && declaration.isCompanion) {
         companionObject = declaration
     }
 }
 
-fun AbstractFirRegularClassBuilder.addDeclarations(declarations: Collection<FirDeclaration>) {
+fun FirRegularClassBuilder.addDeclarations(declarations: Collection<FirDeclaration>) {
     declarations.forEach(this::addDeclaration)
 }
 
@@ -101,7 +101,7 @@ fun FirFile.addDeclaration(declaration: FirDeclaration) {
 fun FirRegularClass.addDeclaration(declaration: FirDeclaration) {
     @Suppress("LiftReturnOrAssignment")
     when (this) {
-        is FirClassImpl -> declarations += declaration
+        is FirRegularClassImpl -> declarations += declaration
         else -> throw IllegalStateException()
     }
 }

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

@@ -32,10 +32,11 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             fields from klass without listOf("symbol", "resolvePhase", "attributes")
         }
 
-        val regularClassBuilder by builder("AbstractFirRegularClassBuilder") {
+        builder(regularClass) {
             parents += classBuilder
             parents += typeParameterRefsOwnerBuilder
-            fields from regularClass without "attributes"
+            defaultNull("companionObject")
+            openBuilder()
         }
 
         val qualifiedAccessBuilder by builder {
@@ -81,12 +82,6 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             openBuilder()
         }
 
-        builder(regularClass) {
-            parents += regularClassBuilder
-            defaultNull("companionObject")
-            openBuilder()
-        }
-
         builder(anonymousObject) {
             parents += classBuilder
         }

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

@@ -31,12 +31,10 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
         noImpl(declarationStatus)
         noImpl(resolvedDeclarationStatus)
 
-        val regularClassConfig: ImplementationContext.() -> Unit = {
+        impl(regularClass) {
             defaultFalse("hasLazyNestedClassifiers", withGetter = true)
         }
 
-        impl(regularClass, "FirClassImpl", regularClassConfig)
-
         impl(anonymousObject)
 
         impl(typeAlias)