[FIR] Rename FirClassImpl to FirRegularClassImpl

Also rename `buildClassImpl` to `buildRegularClass` and get rid of intermediate `AbstractFirRegularClassBuilder`
2020-05-26 11:05:32 +03:00
parent 60fd505a9c
commit 6d37776267
16 changed files with 49 additions and 141 deletions
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.builder.AbstractFirRegularClassBuilder
+import org.jetbrains.kotlin.fir.declarations.builder.FirRegularClassBuilder
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
@@ -118,7 +118,7 @@ class FirJavaClass @FirImplementationDetail internal constructor(
 }

@FirBuilderDsl
-internal class FirJavaClassBuilder : AbstractFirRegularClassBuilder, FirAnnotationContainerBuilder {
+internal class FirJavaClassBuilder : FirRegularClassBuilder(), FirAnnotationContainerBuilder {
    lateinit var visibility: Visibility
    var modality: Modality? = null
    var isTopLevel: Boolean by Delegates.notNull()
@@ -128,16 +128,10 @@ internal class FirJavaClassBuilder : AbstractFirRegularClassBuilder, FirAnnotati
    val existingNestedClassifierNames: MutableList<Name> = mutableListOf()

    override var source: FirSourceElement? = null
-    override lateinit var session: FirSession
    override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
-    override lateinit var name: Name
    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
    override val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf()
-    override lateinit var status: FirDeclarationStatus
-    override lateinit var classKind: ClassKind
    override val declarations: MutableList<FirDeclaration> = mutableListOf()
-    override lateinit var scopeProvider: FirScopeProvider
-    override lateinit var symbol: FirRegularClassSymbol

    override val superTypeRefs: MutableList<FirTypeRef> = mutableListOf()

@@ -169,27 +163,13 @@ internal class FirJavaClassBuilder : AbstractFirRegularClassBuilder, FirAnnotati
        )
    }

-    @Deprecated("Modification of 'hasLazyNestedClassifiers' has no impact for FirClassImplBuilder", level = DeprecationLevel.HIDDEN)
+    @Deprecated("Modification of 'hasLazyNestedClassifiers' has no impact for FirRegularClassImplBuilder", level = DeprecationLevel.HIDDEN)
    override var companionObject: FirRegularClass?
        get() = throw IllegalStateException()
        set(value) {
            throw IllegalStateException()
        }

-    @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()
-        }
-
    @Deprecated("Modification of 'origin' has no impact for FirJavaClassBuilder", level = DeprecationLevel.HIDDEN)
    override var origin: FirDeclarationOrigin
        get() = throw IllegalStateException()
@@ -160,7 +160,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
        }
    }

-    fun T?.toDelegatedSelfType(firClass: AbstractFirRegularClassBuilder): FirResolvedTypeRef =
+    fun T?.toDelegatedSelfType(firClass: FirRegularClassBuilder): FirResolvedTypeRef =
        toDelegatedSelfType(firClass, firClass.symbol)

    fun T?.toDelegatedSelfType(firObject: FirAnonymousObjectBuilder): FirResolvedTypeRef =
@@ -661,7 +661,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
    inner class DataClassMembersGenerator(
        private val session: FirSession,
        private val source: T,
-        private val classBuilder: AbstractFirRegularClassBuilder,
+        private val classBuilder: FirRegularClassBuilder,
        private val primaryConstructor: FirConstructor,
        private val zippedParameters: List<Pair<T, FirProperty>>,
        private val packageFqName: FqName,
@@ -304,7 +304,7 @@ fun FirPropertyBuilder.generateAccessorsByDelegate(
    }
    val ownerSymbol = when (ownerClassBuilder) {
        is FirAnonymousObjectBuilder -> ownerClassBuilder.symbol
-        is AbstractFirRegularClassBuilder -> ownerClassBuilder.symbol
+        is FirRegularClassBuilder -> ownerClassBuilder.symbol
        else -> null
    }
    val isMember = ownerSymbol != null
@@ -317,7 +317,7 @@ fun FirPropertyBuilder.generateAccessorsByDelegate(
                    boundSymbol = ownerSymbol
                }
                typeRef = buildResolvedTypeRef {
-                    val typeParameterNumber = (ownerClassBuilder as? AbstractFirRegularClassBuilder)?.typeParameters?.size ?: 0
+                    val typeParameterNumber = (ownerClassBuilder as? FirRegularClassBuilder)?.typeParameters?.size ?: 0
                    type = ownerSymbol.constructStarProjectedType(typeParameterNumber)
                }
            }
@@ -384,7 +384,7 @@ class DeclarationsConverter(
                    isInline = modifiers.isInlineClass()
                }

-                buildClassImpl {
+                buildRegularClass {
                    source = classNode.toFirSourceElement()
                    session = baseSession
                    origin = FirDeclarationOrigin.Source
@@ -674,7 +674,7 @@ class RawFirBuilder(
                withCapturedTypeParameters {
                    if (!status.isInner) context.capturedTypeParameters = context.capturedTypeParameters.clear()

-                    buildClassImpl {
+                    buildRegularClass {
                        source = classOrObject.toFirSourceElement()
                        session = baseSession
                        origin = FirDeclarationOrigin.Source
@@ -83,7 +83,7 @@ fun deserializeClassToSymbol(
            defaultAnnotationDeserializer ?: FirBuiltinAnnotationDeserializer(session),
            containerSource
        )
-    buildClassImpl {
+    buildRegularClass {
        this.session = session
        origin = FirDeclarationOrigin.Library
        name = classId.shortClassName
@@ -183,7 +183,7 @@ private val ARRAY_CLASSES: Set<Name> = setOf(

 private val JAVA_IO_SERIALIZABLE = ClassId.topLevel(FqName("java.io.Serializable"))

-private fun AbstractFirRegularClassBuilder.addSerializableIfNeeded(classId: ClassId) {
+private fun FirRegularClassBuilder.addSerializableIfNeeded(classId: ClassId) {
    if (!JvmBuiltInsSettings.isSerializableInJava(classId.asSingleFqName().toUnsafe())) return
    superTypeRefs += buildResolvedTypeRef {
        type = ConeClassLikeTypeImpl(
@@ -194,7 +194,7 @@ private fun AbstractFirRegularClassBuilder.addSerializableIfNeeded(classId: Clas
    }
 }

-private fun AbstractFirRegularClassBuilder.addCloneForArrayIfNeeded(classId: ClassId) {
+private fun FirRegularClassBuilder.addCloneForArrayIfNeeded(classId: ClassId) {
    if (classId.packageFqName != KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) return
    if (classId.shortClassName !in ARRAY_CLASSES) return
    superTypeRefs += buildResolvedTypeRef {
@@ -263,7 +263,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
        return simpleFunction
    }

-    fun loadConstructor(proto: ProtoBuf.Constructor, classBuilder: AbstractFirRegularClassBuilder): FirConstructor {
+    fun loadConstructor(proto: ProtoBuf.Constructor, classBuilder: FirRegularClassBuilder): FirConstructor {
        val flags = proto.flags
        val relativeClassName = c.relativeClassName!!
        val symbol = FirConstructorSymbol(CallableId(c.packageFqName, relativeClassName, relativeClassName.shortName()))
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.builder.buildClassImpl
+import org.jetbrains.kotlin.fir.declarations.builder.buildRegularClass
 import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.builder.buildTypeParameter
 import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
@@ -155,7 +155,7 @@ class FirBuiltinSymbolProvider(val session: FirSession, val kotlinScopeProvider:
            val arity = className.substring(prefix.length).toIntOrNull() ?: return null
            syntheticFunctionalInterfaceSymbols.getOrPut(SyntheticFunctionalInterfaceSymbolKey(kind, arity)) {
                FirRegularClassSymbol(this).apply symbol@{
-                    buildClassImpl klass@{
+                    buildRegularClass klass@{
                        session = this@FirBuiltinSymbolProvider.session
                        origin = FirDeclarationOrigin.Synthetic
                        name = relativeClassName.shortName()
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.builder.buildClassImpl
+import org.jetbrains.kotlin.fir.declarations.builder.buildRegularClass
 import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
@@ -36,7 +36,7 @@ class FirClonableSymbolProvider(session: FirSession, scopeProvider: FirScopeProv
        val CLONE: Name = Name.identifier("clone")
    }

-    private val klass = buildClassImpl {
+    private val klass = buildRegularClass {
        resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
        origin = FirDeclarationOrigin.Library
        this.session = session
@@ -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
-}
@@ -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()
 }
@@ -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
    }
@@ -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
@@ -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()
    }
 }
@@ -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
        }
@@ -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)