[FIR] Get rid of FirSealedClass node

Now list of inheritors is hold in attributes of `FirRegularClass`

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt

@@ -97,10 +97,6 @@ abstract class AbstractDiagnosticCollector(
             visitClassAndChildren(regularClass, regularClass.defaultType())
         }
 
-        override fun visitSealedClass(sealedClass: FirSealedClass) {
-            visitClassAndChildren(sealedClass, sealedClass.defaultType())
-        }
-
         override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
             visitClassAndChildren(anonymousObject, anonymousObject.defaultType())
         }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt

@@ -23,10 +23,6 @@ class DeclarationCheckersDiagnosticComponent(collector: AbstractDiagnosticCollec
         runCheck { checkers.memberDeclarationCheckers.check(regularClass, data, it) }
     }
 
-    override fun visitSealedClass(sealedClass: FirSealedClass, data: CheckerContext) {
-        runCheck { checkers.memberDeclarationCheckers.check(sealedClass, data, it) }
-    }
-
     override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: CheckerContext) {
         runCheck { checkers.memberDeclarationCheckers.check(simpleFunction, data, it) }
     }

compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt

@@ -376,10 +376,6 @@ class MultiModuleHtmlFirDump(private val outputRoot: File) {
                     visitElement(regularClass)
                 }
 
-                override fun visitSealedClass(sealedClass: FirSealedClass) {
-                    visitRegularClass(sealedClass)
-                }
-
                 fun indexDeclaration(symbolOwner: FirSymbolOwner<*>) {
                     symbols[symbolOwner.symbol] = location
                     symbolIds[symbolOwner.symbol] = symbolCounter++

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.inference.isSuspendFunctionType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
+import org.jetbrains.kotlin.fir.resolve.transformers.sealedInheritors
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.types.*
@@ -155,8 +156,10 @@ class FirElementSerializer private constructor(
             }
         }
 
-        if (klass is FirSealedClass) {
+        if (klass is FirRegularClass && klass.modality == Modality.SEALED) {
-            for (inheritorId in klass.inheritors) {
+            val inheritors = klass.sealedInheritors
+            requireNotNull(inheritors)
+            for (inheritorId in inheritors) {
                 builder.addSealedSubclassFqName(stringTable.getQualifiedClassNameIndex(inheritorId))
             }
         }

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt

@@ -25,8 +25,8 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
-import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
@@ -384,13 +384,7 @@ class DeclarationsConverter(
                     isInline = modifiers.isInlineClass()
                 }
 
-                val classBuilder = if (status.modality == Modality.SEALED) {
+                buildClassImpl {
-                    FirSealedClassBuilder()
-                } else {
-                    FirClassImplBuilder()
-                }
-
-                classBuilder.apply {
                     source = classNode.toFirSourceElement()
                     session = baseSession
                     origin = FirDeclarationOrigin.Source
@@ -443,7 +437,7 @@ class DeclarationsConverter(
 
                     val secondaryConstructors = classBody.getChildNodesByType(SECONDARY_CONSTRUCTOR)
                     val classWrapper = ClassWrapper(
-                        className, modifiers, classKind, classBuilder,
+                        className, modifiers, classKind, this,
                         hasPrimaryConstructor = primaryConstructor != null,
                         hasSecondaryConstructor = secondaryConstructors.isNotEmpty(),
                         hasDefaultConstructor = if (primaryConstructor != null) !primaryConstructor!!.hasValueParameters()
@@ -489,7 +483,7 @@ class DeclarationsConverter(
                         generateValuesFunction(baseSession, context.packageFqName, context.className)
                         generateValueOfFunction(baseSession, context.packageFqName, context.className)
                     }
-                }.build()
+                }
             }
         }
     }

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -45,19 +45,7 @@ import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
-import kotlin.collections.MutableList
-import kotlin.collections.any
 import kotlin.collections.contains
-import kotlin.collections.filterIsInstance
-import kotlin.collections.first
-import kotlin.collections.firstOrNull
-import kotlin.collections.forEach
-import kotlin.collections.isNotEmpty
-import kotlin.collections.lastOrNull
-import kotlin.collections.plusAssign
-import kotlin.collections.reverse
-import kotlin.collections.withIndex
-import kotlin.collections.zip
 
 class RawFirBuilder(
     session: FirSession, val baseScopeProvider: FirScopeProvider, val stubMode: Boolean
@@ -686,8 +674,7 @@ class RawFirBuilder(
                 withCapturedTypeParameters {
                     if (!status.isInner) context.capturedTypeParameters = context.capturedTypeParameters.clear()
 
-                    val classBuilder = if (status.modality == Modality.SEALED) FirSealedClassBuilder() else FirClassImplBuilder()
+                    buildClassImpl {
-                    classBuilder.apply {
                         source = classOrObject.toFirSourceElement()
                         session = baseSession
                         origin = FirDeclarationOrigin.Source
@@ -725,7 +712,7 @@ class RawFirBuilder(
                                     delegatedSuperType,
                                     delegatedSelfType,
                                     classOrObject,
-                                    classBuilder, hasPrimaryConstructor = primaryConstructor != null,
+                                    this, hasPrimaryConstructor = primaryConstructor != null,
                                     typeParameters
                                 ),
                             )
@@ -750,7 +737,7 @@ class RawFirBuilder(
                             generateValuesFunction(baseSession, context.packageFqName, context.className)
                             generateValueOfFunction(baseSession, context.packageFqName, context.className)
                         }
-                    }.build()
+                    }
                 }
             }
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.fir.generateValueOfFunction
 import org.jetbrains.kotlin.fir.generateValuesFunction
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirClonableSymbolProvider.Companion.CLONABLE_CLASS_ID
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirClonableSymbolProvider.Companion.CLONE
+import org.jetbrains.kotlin.fir.resolve.transformers.sealedInheritors
 import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
@@ -70,7 +71,6 @@ fun deserializeClassToSymbol(
         isInline = Flags.IS_INLINE_CLASS.get(classProto.flags)
     }
     val isSealed = modality == Modality.SEALED
-    val classBuilder = if (isSealed) FirSealedClassBuilder() else FirClassImplBuilder()
     val context =
         parentContext?.childContext(
             classProto.typeParameterList,
@@ -83,7 +83,7 @@ fun deserializeClassToSymbol(
             defaultAnnotationDeserializer ?: FirBuiltinAnnotationDeserializer(session),
             containerSource
         )
-    classBuilder.apply {
+    buildClassImpl {
         this.session = session
         origin = FirDeclarationOrigin.Library
         name = classId.shortClassName
@@ -154,13 +154,16 @@ fun deserializeClassToSymbol(
         }
 
         if (isSealed) {
-            classProto.sealedSubclassFqNameList.mapTo((this as FirSealedClassBuilder).inheritors) {
+
-                ClassId.fromString(nameResolver.getQualifiedClassName(it))
-            }
         }
         addCloneForArrayIfNeeded(classId)
         addSerializableIfNeeded(classId)
-    }.build().also {
+    }.also {
+        if (isSealed) {
+            it.sealedInheritors = classProto.sealedSubclassFqNameList.map { nameIndex ->
+                ClassId.fromString(nameResolver.getQualifiedClassName(nameIndex))
+            }
+        }
         (it.annotations as MutableList<FirAnnotationCall>) += context.annotationDeserializer.loadClassAnnotations(classProto, context.nameResolver)
     }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsTransformer.kt

@@ -10,9 +10,9 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
@@ -35,13 +35,13 @@ class FirSealedClassInheritorsTransformer : FirTransformer<Nothing?>() {
     }
 
     override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirDeclaration> {
-        val sealedClassInheritorsMap = mutableMapOf<FirSealedClass, MutableList<ClassId>>()
+        val sealedClassInheritorsMap = mutableMapOf<FirRegularClass, MutableList<ClassId>>()
         file.accept(InheritorsCollector, sealedClassInheritorsMap)
         if (sealedClassInheritorsMap.isEmpty()) return file.compose()
         return file.transform(InheritorsTransformer(sealedClassInheritorsMap), null)
     }
 
-    private class InheritorsTransformer(private val inheritorsMap: MutableMap<FirSealedClass, MutableList<ClassId>>) : FirTransformer<Nothing?>() {
+    private class InheritorsTransformer(private val inheritorsMap: MutableMap<FirRegularClass, MutableList<ClassId>>) : FirTransformer<Nothing?>() {
         override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
             return element.compose()
         }
@@ -51,34 +51,32 @@ class FirSealedClassInheritorsTransformer : FirTransformer<Nothing?>() {
         }
 
         override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): CompositeTransformResult<FirStatement> {
+            if (regularClass.modality == Modality.SEALED) {
+                val inheritors = inheritorsMap.remove(regularClass)
+                if (inheritors != null) {
+                    regularClass.sealedInheritors = inheritors
+                }
+            }
             if (inheritorsMap.isEmpty()) return regularClass.compose()
             return (regularClass.transformChildren(this, data) as FirRegularClass).compose()
         }
-
-        override fun transformSealedClass(sealedClass: FirSealedClass, data: Nothing?): CompositeTransformResult<FirStatement> {
-            val inheritors = inheritorsMap.remove(sealedClass)
-            if (inheritors != null) {
-                sealedClass.replaceInheritors(inheritors)
-            }
-            return transformRegularClass(sealedClass, data)
-        }
     }
 
-    private object InheritorsCollector : FirDefaultVisitor<Unit, MutableMap<FirSealedClass, MutableList<ClassId>>>() {
+    private object InheritorsCollector : FirDefaultVisitor<Unit, MutableMap<FirRegularClass, MutableList<ClassId>>>() {
-        override fun visitElement(element: FirElement, data: MutableMap<FirSealedClass, MutableList<ClassId>>) {}
+        override fun visitElement(element: FirElement, data: MutableMap<FirRegularClass, MutableList<ClassId>>) {}
 
-        override fun visitFile(file: FirFile, data: MutableMap<FirSealedClass, MutableList<ClassId>>) {
+        override fun visitFile(file: FirFile, data: MutableMap<FirRegularClass, MutableList<ClassId>>) {
             file.declarations.forEach { it.accept(this, data) }
         }
 
-        override fun visitRegularClass(regularClass: FirRegularClass, data: MutableMap<FirSealedClass, MutableList<ClassId>>) {
+        override fun visitRegularClass(regularClass: FirRegularClass, data: MutableMap<FirRegularClass, MutableList<ClassId>>) {
             regularClass.declarations.forEach { it.accept(this, data) }
 
             val symbolProvider = regularClass.session.firSymbolProvider
 
             for (typeRef in regularClass.superTypeRefs) {
                 val parent = extractClassFromTypeRef(symbolProvider, typeRef).takeIf { it?.modality == Modality.SEALED } ?: continue
-                val inheritors = data.computeIfAbsent(parent as FirSealedClass) { mutableListOf() }
+                val inheritors = data.computeIfAbsent(parent) { mutableListOf() }
                 inheritors += regularClass.symbol.classId
             }
         }
@@ -93,4 +91,8 @@ class FirSealedClassInheritorsTransformer : FirTransformer<Nothing?>() {
             }
         }
     }
-}
+}
+
+object SealedClassInheritorsKey : FirDeclarationDataKey()
+
+var FirRegularClass.sealedInheritors: List<ClassId>? by FirDeclarationDataRegistry.data(SealedClassInheritorsKey)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt

@@ -8,7 +8,10 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.collectEnumEntries
+import org.jetbrains.kotlin.fir.declarations.modality
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
@@ -59,7 +62,7 @@ class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyRe
                 val klass = lookupTag.toSymbol(bodyResolveComponents.session)?.fir as? FirRegularClass ?: return null
                 when {
                     klass.classKind == ClassKind.ENUM_CLASS -> checkEnumExhaustiveness(whenExpression, klass, nullable)
-                    klass.modality == Modality.SEALED -> checkSealedClassExhaustiveness(whenExpression, klass as FirSealedClass, nullable)
+                    klass.modality == Modality.SEALED -> checkSealedClassExhaustiveness(whenExpression, klass, nullable)
                     else -> return null
                 }
             }
@@ -118,11 +121,16 @@ class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyRe
 
     // ------------------------ Sealed class exhaustiveness ------------------------
 
-    private fun checkSealedClassExhaustiveness(whenExpression: FirWhenExpression, sealedClass: FirSealedClass, nullable: Boolean): Boolean {
+    private fun checkSealedClassExhaustiveness(
-        if (sealedClass.inheritors.isEmpty()) return true
+        whenExpression: FirWhenExpression,
+        sealedClass: FirRegularClass,
+        nullable: Boolean
+    ): Boolean {
+        val inheritors = sealedClass.sealedInheritors
+        if (inheritors.isNullOrEmpty()) return true
         val data = SealedExhaustivenessData(
             sealedClass.session.firSymbolProvider,
-            sealedClass.inheritors.toMutableSet(),
+            inheritors.toMutableSet(),
             !nullable
         )
         for (branch in whenExpression.branches) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt

@@ -155,10 +155,6 @@ class FirContractResolveTransformer(
             return owner.compose()
         }
 
-        override fun transformSealedClass(sealedClass: FirSealedClass, data: ResolutionMode): CompositeTransformResult<FirStatement> {
-            return transformRegularClass(sealedClass, data)
-        }
-
         override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult<FirStatement> {
             regularClass.updatePhase()
             context.storeClassIfNotNested(regularClass)

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

@@ -1,64 +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
-
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSourceElement
-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.name.ClassId
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.fir.visitors.*
-
-/*
- * This file was generated automatically
- * DO NOT MODIFY IT MANUALLY
- */
-
-abstract class FirSealedClass : FirRegularClass() {
-    abstract override val source: FirSourceElement?
-    abstract override val session: FirSession
-    abstract override val resolvePhase: FirResolvePhase
-    abstract override val origin: FirDeclarationOrigin
-    abstract override val attributes: FirDeclarationAttributes
-    abstract override val annotations: List<FirAnnotationCall>
-    abstract override val typeParameters: List<FirTypeParameterRef>
-    abstract override val status: FirDeclarationStatus
-    abstract override val classKind: ClassKind
-    abstract override val declarations: List<FirDeclaration>
-    abstract override val scopeProvider: FirScopeProvider
-    abstract override val name: Name
-    abstract override val symbol: FirRegularClassSymbol
-    abstract override val companionObject: FirRegularClass?
-    abstract override val hasLazyNestedClassifiers: Boolean
-    abstract override val superTypeRefs: List<FirTypeRef>
-    abstract override val controlFlowGraphReference: FirControlFlowGraphReference
-    abstract val inheritors: List<ClassId>
-
-    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSealedClass(this, data)
-
-    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
-
-    abstract override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
-
-    abstract fun replaceInheritors(newInheritors: List<ClassId>)
-
-    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSealedClass
-
-    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirSealedClass
-
-    abstract override fun <D> transformDeclarations(transformer: FirTransformer<D>, data: D): FirSealedClass
-
-    abstract override fun <D> transformCompanionObject(transformer: FirTransformer<D>, data: D): FirSealedClass
-
-    abstract override fun <D> transformSuperTypeRefs(transformer: FirTransformer<D>, data: D): FirSealedClass
-
-    abstract override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirSealedClass
-}

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

@@ -1,99 +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 kotlin.contracts.*
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirSession
-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.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes
-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.FirSealedClass
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.builder.AbstractFirRegularClassBuilder
-import org.jetbrains.kotlin.fir.declarations.impl.FirSealedClassImpl
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
-import org.jetbrains.kotlin.fir.references.impl.FirEmptyControlFlowGraphReference
-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.ClassId
-import org.jetbrains.kotlin.name.Name
-
-/*
- * This file was generated automatically
- * DO NOT MODIFY IT MANUALLY
- */
-
-@FirBuilderDsl
-class FirSealedClassBuilder : AbstractFirRegularClassBuilder, FirAnnotationContainerBuilder {
-    override var source: FirSourceElement? = null
-    override lateinit var session: FirSession
-    override 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
-    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
-    override val superTypeRefs: MutableList<FirTypeRef> = mutableListOf()
-    val inheritors: MutableList<ClassId> = mutableListOf()
-
-    override fun build(): FirSealedClass {
-        return FirSealedClassImpl(
-            source,
-            session,
-            resolvePhase,
-            origin,
-            annotations,
-            typeParameters,
-            status,
-            classKind,
-            declarations,
-            scopeProvider,
-            name,
-            symbol,
-            companionObject,
-            superTypeRefs,
-            inheritors,
-        )
-    }
-
-
-    @Deprecated("Modification of 'hasLazyNestedClassifiers' has no impact for FirSealedClassBuilder", level = DeprecationLevel.HIDDEN)
-    override var hasLazyNestedClassifiers: Boolean
-        get() = throw IllegalStateException()
-        set(value) {
-            throw IllegalStateException()
-        }
-
-    @Deprecated("Modification of 'controlFlowGraphReference' has no impact for FirSealedClassBuilder", level = DeprecationLevel.HIDDEN)
-    override var controlFlowGraphReference: FirControlFlowGraphReference
-        get() = throw IllegalStateException()
-        set(value) {
-            throw IllegalStateException()
-        }
-}
-
-@OptIn(ExperimentalContracts::class)
-inline fun buildSealedClass(init: FirSealedClassBuilder.() -> Unit): FirSealedClass {
-    contract {
-        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
-    }
-    return FirSealedClassBuilder().apply(init).build()
-}

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

@@ -1,122 +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.impl
-
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes
-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.FirSealedClass
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
-import org.jetbrains.kotlin.fir.references.impl.FirEmptyControlFlowGraphReference
-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.name.ClassId
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.fir.visitors.*
-
-/*
- * This file was generated automatically
- * DO NOT MODIFY IT MANUALLY
- */
-
-internal class FirSealedClassImpl(
-    override val source: FirSourceElement?,
-    override val session: FirSession,
-    override var resolvePhase: FirResolvePhase,
-    override val origin: FirDeclarationOrigin,
-    override val annotations: MutableList<FirAnnotationCall>,
-    override val typeParameters: MutableList<FirTypeParameterRef>,
-    override var status: FirDeclarationStatus,
-    override val classKind: ClassKind,
-    override val declarations: MutableList<FirDeclaration>,
-    override val scopeProvider: FirScopeProvider,
-    override val name: Name,
-    override val symbol: FirRegularClassSymbol,
-    override var companionObject: FirRegularClass?,
-    override val superTypeRefs: MutableList<FirTypeRef>,
-    override val inheritors: MutableList<ClassId>,
-) : FirSealedClass() {
-    override val attributes: FirDeclarationAttributes = FirDeclarationAttributes()
-    override val hasLazyNestedClassifiers: Boolean get() = false
-    override var controlFlowGraphReference: FirControlFlowGraphReference = FirEmptyControlFlowGraphReference
-
-    init {
-        symbol.bind(this)
-    }
-
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        annotations.forEach { it.accept(visitor, data) }
-        typeParameters.forEach { it.accept(visitor, data) }
-        status.accept(visitor, data)
-        declarations.forEach { it.accept(visitor, data) }
-        superTypeRefs.forEach { it.accept(visitor, data) }
-        controlFlowGraphReference.accept(visitor, data)
-    }
-
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirSealedClassImpl {
-        transformAnnotations(transformer, data)
-        typeParameters.transformInplace(transformer, data)
-        transformStatus(transformer, data)
-        transformDeclarations(transformer, data)
-        companionObject = declarations.asSequence().filterIsInstance<FirRegularClass>().firstOrNull { it.status.isCompanion }
-        transformSuperTypeRefs(transformer, data)
-        transformControlFlowGraphReference(transformer, data)
-        return this
-    }
-
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSealedClassImpl {
-        annotations.transformInplace(transformer, data)
-        return this
-    }
-
-    override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirSealedClassImpl {
-        status = status.transformSingle(transformer, data)
-        return this
-    }
-
-    override fun <D> transformDeclarations(transformer: FirTransformer<D>, data: D): FirSealedClassImpl {
-        declarations.transformInplace(transformer, data)
-        return this
-    }
-
-    override fun <D> transformCompanionObject(transformer: FirTransformer<D>, data: D): FirSealedClassImpl {
-        companionObject = companionObject?.transformSingle(transformer, data)
-        return this
-    }
-
-    override fun <D> transformSuperTypeRefs(transformer: FirTransformer<D>, data: D): FirSealedClassImpl {
-        superTypeRefs.transformInplace(transformer, data)
-        return this
-    }
-
-    override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirSealedClassImpl {
-        controlFlowGraphReference = controlFlowGraphReference.transformSingle(transformer, data)
-        return this
-    }
-
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
-        resolvePhase = newResolvePhase
-    }
-
-    override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>) {
-        superTypeRefs.clear()
-        superTypeRefs.addAll(newSuperTypeRefs)
-    }
-
-    override fun replaceInheritors(newInheritors: List<ClassId>) {
-        inheritors.clear()
-        inheritors.addAll(newInheritors)
-    }
-}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt

@@ -38,7 +38,6 @@ import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
@@ -264,10 +263,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformElement(regularClass, data)
     }
 
-    open fun transformSealedClass(sealedClass: FirSealedClass, data: D): CompositeTransformResult<FirStatement> {
-        return transformElement(sealedClass, data)
-    }
-
     open fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult<FirDeclaration> {
         return transformElement(typeAlias, data)
     }
@@ -744,10 +739,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformRegularClass(regularClass, data)
     }
 
-    final override fun visitSealedClass(sealedClass: FirSealedClass, data: D): CompositeTransformResult<FirStatement> {
-        return transformSealedClass(sealedClass, data)
-    }
-
     final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): CompositeTransformResult<FirDeclaration> {
         return transformTypeAlias(typeAlias, data)
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt

@@ -38,7 +38,6 @@ import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
@@ -198,8 +197,6 @@ abstract class FirVisitor<out R, in D> {
 
     open fun visitRegularClass(regularClass: FirRegularClass, data: D): R  = visitElement(regularClass, data)
 
-    open fun visitSealedClass(sealedClass: FirSealedClass, data: D): R  = visitElement(sealedClass, data)
-
     open fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): R  = visitElement(typeAlias, data)
 
     open fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>, data: D): R  = visitElement(function, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt

@@ -38,7 +38,6 @@ import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
@@ -262,10 +261,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(regularClass)
     }
 
-    open fun visitSealedClass(sealedClass: FirSealedClass) {
-        visitElement(sealedClass)
-    }
-
     open fun visitTypeAlias(typeAlias: FirTypeAlias) {
         visitElement(typeAlias)
     }
@@ -742,10 +737,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitRegularClass(regularClass)
     }
 
-    final override fun visitSealedClass(sealedClass: FirSealedClass, data: Nothing?) {
-        visitSealedClass(sealedClass)
-    }
-
     final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Nothing?) {
         visitTypeAlias(typeAlias)
     }

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

@@ -341,10 +341,6 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
         regularClass.declarations.renderDeclarations()
     }
 
-    override fun visitSealedClass(sealedClass: FirSealedClass) {
-        visitRegularClass(sealedClass)
-    }
-
     override fun visitEnumEntry(enumEntry: FirEnumEntry) {
         enumEntry.annotations.renderAnnotations()
         visitCallableDeclaration(enumEntry)

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

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.declarations.builder.AbstractFirRegularClassBuil
 import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterBuilder
 import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirFileImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirSealedClassImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -19,7 +18,6 @@ import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeFlexibleType
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
-import java.lang.IllegalStateException
 
 fun FirTypeParameterBuilder.addDefaultBoundIfNecessary(isFlexible: Boolean = false) {
     if (bounds.isEmpty()) {
@@ -104,7 +102,6 @@ fun FirRegularClass.addDeclaration(declaration: FirDeclaration) {
     @Suppress("LiftReturnOrAssignment")
     when (this) {
         is FirClassImpl -> declarations += declaration
-        is FirSealedClassImpl -> declarations += declaration
         else -> throw IllegalStateException()
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.visitors
 
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
-import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
@@ -85,10 +84,6 @@ abstract class FirDefaultTransformer<D> : FirTransformer<D>() {
         return transformWrappedArgumentExpression(namedArgumentExpression, data)
     }
 
-    override fun transformSealedClass(sealedClass: FirSealedClass, data: D): CompositeTransformResult<FirStatement> {
-        return transformRegularClass(sealedClass, data)
-    }
-
     override fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult<FirStatement> {
         return transformExpression(errorExpression, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.visitors
 
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
-import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.types.*
@@ -81,10 +80,6 @@ abstract class FirDefaultVisitor<R, D> : FirVisitor<R, D>() {
         return visitWrappedArgumentExpression(namedArgumentExpression, data)
     }
 
-    override fun visitSealedClass(sealedClass: FirSealedClass, data: D): R {
-        return visitRegularClass(sealedClass, data)
-    }
-
     override fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): R {
         return visitExpression(errorExpression, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.visitors
 
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
-import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.types.*
@@ -81,10 +80,6 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() {
         return visitWrappedArgumentExpression(namedArgumentExpression)
     }
 
-    override fun visitSealedClass(sealedClass: FirSealedClass) {
-        return visitRegularClass(sealedClass)
-    }
-
     override fun visitErrorExpression(errorExpression: FirErrorExpression) {
         return visitExpression(errorExpression)
     }

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

@@ -87,11 +87,6 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             openBuilder()
         }
 
-        builder(sealedClass) {
-            parents += regularClassBuilder
-            defaultNull("companionObject")
-        }
-
         builder(anonymousObject) {
             parents += classBuilder
         }

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

@@ -46,7 +46,6 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val classLikeDeclaration = element("ClassLikeDeclaration", Declaration, annotatedDeclaration, statement, symbolOwner)
     val klass = element("Class", Declaration, classLikeDeclaration, statement, typeParameterRefsOwner)
     val regularClass = element("RegularClass", Declaration, memberDeclaration, typeParameterRefsOwner, klass)
-    val sealedClass = element("SealedClass", Declaration, regularClass)
     val typeAlias = element("TypeAlias", Declaration, classLikeDeclaration, memberDeclaration, typeParametersOwner)
 
     val function = element("Function", Declaration, callableDeclaration, targetElement, typeParameterRefsOwner, statement)

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

@@ -37,8 +37,6 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
 
         impl(regularClass, "FirClassImpl", regularClassConfig)
 
-        impl(sealedClass, config = regularClassConfig)
-
         impl(anonymousObject)
 
         impl(typeAlias)

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

@@ -253,10 +253,6 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
             +controlFlowGraphReferenceField
         }
 
-        sealedClass.configure {
-            +fieldList("inheritors", classIdType, withReplace = true)
-        }
-
         typeAlias.configure {
             +typeParameters
             parentArg(classLikeDeclaration, "F", typeAlias)