[FIR] Add special node for sealed classes

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

@@ -323,6 +323,10 @@ 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/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt

@@ -372,15 +372,25 @@ class DeclarationsConverter(
                 isData = modifiers.isDataClass() && classKind != ClassKind.OBJECT
                 isInline = modifiers.hasInline()
             }
-            val firClass = FirClassImpl(
+            val firClass = if (status.modality == Modality.SEALED) {
-                null,
+                FirSealedClassImpl(
-                session,
+                    null,
-                className,
+                    session,
-                status,
+                    className,
-                classKind,
+                    status,
-                FirClassSymbol(context.currentClassId)
+                    classKind,
-
+                    FirClassSymbol(context.currentClassId)
-            )
+                )
+            } else {
+                FirClassImpl(
+                    null,
+                    session,
+                    className,
+                    status,
+                    classKind,
+                    FirClassSymbol(context.currentClassId)
+                )
+            }
             firClass.annotations += modifiers.annotations
             firClass.typeParameters += firTypeParameters
             firClass.joinTypeParameters(typeConstraints)

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt

@@ -12,10 +12,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.addDeclaration
-import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
+import org.jetbrains.kotlin.fir.declarations.impl.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
-import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.expressions.impl.*
 import org.jetbrains.kotlin.fir.references.impl.FirImplicitThisReference
 import org.jetbrains.kotlin.fir.references.impl.FirResolvedCallableReferenceImpl
@@ -29,7 +26,7 @@ import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtParameter
 
 fun List<Pair<KtParameter?, FirProperty>>.generateComponentFunctions(
-    session: FirSession, firClass: FirClassImpl, packageFqName: FqName, classFqName: FqName,
+    session: FirSession, firClass: FirModifiableRegularClass, packageFqName: FqName, classFqName: FqName,
     firPrimaryConstructor: FirConstructor
 ) {
     var componentIndex = 1
@@ -81,7 +78,7 @@ fun List<Pair<KtParameter?, FirProperty>>.generateComponentFunctions(
 private val copyName = Name.identifier("copy")
 
 fun List<Pair<KtParameter?, FirProperty>>.generateCopyFunction(
-    session: FirSession, classOrObject: KtClassOrObject?, firClass: FirClassImpl, packageFqName: FqName, classFqName: FqName,
+    session: FirSession, classOrObject: KtClassOrObject?, firClass: FirModifiableRegularClass, packageFqName: FqName, classFqName: FqName,
     firPrimaryConstructor: FirConstructor
 ) {
     val symbol = FirNamedFunctionSymbol(CallableId(packageFqName, classFqName, copyName))

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

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.*
-import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
@@ -475,14 +474,25 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                     isData = (classOrObject as? KtClass)?.isData() == true
                     isInline = classOrObject.hasModifier(INLINE_KEYWORD)
                 }
-                val firClass = FirClassImpl(
+                val firClass = if (status.modality == Modality.SEALED) {
-                    classOrObject,
+                    FirSealedClassImpl(
-                    session,
+                        classOrObject,
-                    classOrObject.nameAsSafeName,
+                        session,
-                    status,
+                        classOrObject.nameAsSafeName,
-                    classKind,
+                        status,
-                    FirClassSymbol(context.currentClassId)
+                        classKind,
-                )
+                        FirClassSymbol(context.currentClassId)
+                    )
+                } else {
+                    FirClassImpl(
+                        classOrObject,
+                        session,
+                        classOrObject.nameAsSafeName,
+                        status,
+                        classKind,
+                        FirClassSymbol(context.currentClassId)
+                    )
+                }
                 classOrObject.extractAnnotationsTo(firClass)
                 classOrObject.extractTypeParametersTo(firClass)
                 val delegatedSelfType = classOrObject.toDelegatedSelfType(firClass)

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

@@ -5,12 +5,14 @@
 
 package org.jetbrains.kotlin.fir.deserialization
 
+import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.addDeclarations
 import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirEnumEntryImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirSealedClassImpl
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
@@ -37,9 +39,10 @@ fun deserializeClassToSymbol(
 ) {
     val flags = classProto.flags
     val kind = Flags.CLASS_KIND.get(flags)
+    val modality = ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
     val status = FirDeclarationStatusImpl(
         ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
-        ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
+        modality
     ).apply {
         isExpect = Flags.IS_EXPECT_CLASS.get(flags)
         isActual = false
@@ -48,14 +51,26 @@ fun deserializeClassToSymbol(
         isData = Flags.IS_DATA.get(classProto.flags)
         isInline = Flags.IS_INLINE_CLASS.get(classProto.flags)
     }
-    FirClassImpl(
+    val firClass = if (modality == Modality.SEALED) {
-        null,
+        FirSealedClassImpl(
-        session,
+            null,
-        classId.shortClassName,
+            session,
-        status,
+            classId.shortClassName,
-        ProtoEnumFlags.classKind(kind),
+            status,
-        symbol
+            ProtoEnumFlags.classKind(kind),
-    ).apply {
+            symbol
+        )
+    } else {
+        FirClassImpl(
+            null,
+            session,
+            classId.shortClassName,
+            status,
+            ProtoEnumFlags.classKind(kind),
+            symbol
+        )
+    }
+    firClass.apply {
         resolvePhase = FirResolvePhase.DECLARATIONS
         val context =
             parentContext?.childContext(

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

@@ -288,6 +288,10 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         regularClass.declarations.renderDeclarations()
     }
 
+    override fun visitSealedClass(sealedClass: FirSealedClass) {
+        visitRegularClass(sealedClass)
+    }
+
     override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
         anonymousObject.annotations.renderAnnotations()
         print("object : ")

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

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirEnumEntryImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableRegularClass
 import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
@@ -40,14 +40,14 @@ inline val FirMemberDeclaration.isLateInit: Boolean get() = status.isLateInit
 inline val FirPropertyAccessor.modality get() = status.modality
 inline val FirPropertyAccessor.visibility get() = status.visibility
 
-fun FirClassImpl.addDeclaration(declaration: FirDeclaration) {
+fun FirModifiableRegularClass.addDeclaration(declaration: FirDeclaration) {
     declarations += declaration
     if (companionObject == null && declaration is FirRegularClass && declaration.isCompanion) {
         companionObject = declaration
     }
 }
 
-fun FirClassImpl.addDeclarations(declarations: Collection<FirDeclaration>) {
+fun FirModifiableRegularClass.addDeclarations(declarations: Collection<FirDeclaration>) {
     declarations.forEach(this::addDeclaration)
 }
 

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2019 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 com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+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
+ */
+
+interface FirSealedClass : FirRegularClass {
+    override val psi: PsiElement?
+    override val session: FirSession
+    override val resolvePhase: FirResolvePhase
+    override val name: Name
+    override val annotations: List<FirAnnotationCall>
+    override val typeParameters: List<FirTypeParameter>
+    override val status: FirDeclarationStatus
+    override val supertypesComputationStatus: SupertypesComputationStatus
+    override val classKind: ClassKind
+    override val declarations: List<FirDeclaration>
+    override val symbol: FirClassSymbol
+    override val companionObject: FirRegularClass?
+    override val superTypeRefs: List<FirTypeRef>
+    val inheritors: List<ClassId>
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSealedClass(this, data)
+
+    fun replaceInheritors(newInheritors: List<ClassId>)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt

@@ -33,7 +33,7 @@ class FirClassImpl(
     override var status: FirDeclarationStatus,
     override val classKind: ClassKind,
     override val symbol: FirClassSymbol
-) : FirRegularClass, FirModifiableClass, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement {
+) : FirRegularClass, FirModifiableRegularClass, FirAbstractAnnotatedElement {
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableRegularClass.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-2019 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 com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+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.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.SupertypesComputationStatus
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+interface FirModifiableRegularClass : FirRegularClass, FirModifiableClass, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement {
+    override val psi: PsiElement?
+    override val session: FirSession
+    override var resolvePhase: FirResolvePhase
+    override val name: Name
+    override val annotations: MutableList<FirAnnotationCall>
+    override val typeParameters: MutableList<FirTypeParameter>
+    override var status: FirDeclarationStatus
+    override var supertypesComputationStatus: SupertypesComputationStatus
+    override val classKind: ClassKind
+    override val declarations: MutableList<FirDeclaration>
+    override val symbol: FirClassSymbol
+    override var companionObject: FirRegularClass?
+    override val superTypeRefs: MutableList<FirTypeRef>
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableRegularClass
+
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    override fun replaceSupertypesComputationStatus(newSupertypesComputationStatus: SupertypesComputationStatus)
+
+    override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
+}

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

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2010-2019 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 com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+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.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.SupertypesComputationStatus
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+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
+ */
+
+class FirSealedClassImpl(
+    override val psi: PsiElement?,
+    override val session: FirSession,
+    override val name: Name,
+    override var status: FirDeclarationStatus,
+    override val classKind: ClassKind,
+    override val symbol: FirClassSymbol
+) : FirSealedClass, FirModifiableRegularClass, FirAbstractAnnotatedElement {
+    override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
+    override var supertypesComputationStatus: SupertypesComputationStatus = SupertypesComputationStatus.NOT_COMPUTED
+    override val declarations: MutableList<FirDeclaration> = mutableListOf()
+    override var companionObject: FirRegularClass? = null
+    override val superTypeRefs: MutableList<FirTypeRef> = mutableListOf()
+    override val inheritors: MutableList<ClassId> = mutableListOf()
+
+    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.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.forEach { it.accept(visitor, data) }
+        declarations.forEach { it.accept(visitor, data) }
+        superTypeRefs.forEach { it.accept(visitor, data) }
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirSealedClassImpl {
+        annotations.transformInplace(transformer, data)
+        typeParameters.transformInplace(transformer, data)
+        status = status.transformSingle(transformer, data)
+        (declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.transformInplace(transformer, data)
+        declarations.transformInplace(transformer, data)
+        companionObject = declarations.asSequence().filterIsInstance<FirRegularClass>().firstOrNull { it.status.isCompanion }
+        superTypeRefs.transformInplace(transformer, data)
+        return this
+    }
+
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
+        resolvePhase = newResolvePhase
+    }
+
+    override fun replaceSupertypesComputationStatus(newSupertypesComputationStatus: SupertypesComputationStatus) {
+        supertypesComputationStatus = newSupertypesComputationStatus
+    }
+
+    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/src/org/jetbrains/kotlin/fir/visitors/FirDefaultTransformer.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.visitors
 
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.types.*
 
@@ -85,5 +85,9 @@ abstract class FirDefaultTransformer<D> : FirTransformer<D>() {
     override fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
         return transformWrappedArgumentExpression(namedArgumentExpression, data)
     }
+
+    override fun transformSealedClass(sealedClass: FirSealedClass, data: D): CompositeTransformResult<FirStatement> {
+        return transformRegularClass(sealedClass, data)
+    }
 }
 

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.visitors
 
 import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.types.*
 
@@ -81,5 +82,9 @@ abstract class FirDefaultVisitor<R, D> : FirVisitor<R, D>() {
     override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): R {
         return visitWrappedArgumentExpression(namedArgumentExpression, data)
     }
+
+    override fun visitSealedClass(sealedClass: FirSealedClass, data: D): R {
+        return visitRegularClass(sealedClass, data)
+    }
 }
 

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.visitors
 
 import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.types.*
 
@@ -81,4 +82,8 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() {
     override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) {
         return visitWrappedArgumentExpression(namedArgumentExpression)
     }
+
+    override fun visitSealedClass(sealedClass: FirSealedClass) {
+        return visitRegularClass(sealedClass)
+    }
 }

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

@@ -36,6 +36,7 @@ import org.jetbrains.kotlin.fir.declarations.FirField
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 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.FirEnumEntry
 import org.jetbrains.kotlin.fir.declarations.FirFunction
@@ -242,6 +243,10 @@ 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)
     }
@@ -666,6 +671,10 @@ 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/src/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt

@@ -36,6 +36,7 @@ import org.jetbrains.kotlin.fir.declarations.FirField
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 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.FirEnumEntry
 import org.jetbrains.kotlin.fir.declarations.FirFunction
@@ -180,6 +181,8 @@ 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 visitEnumEntry(enumEntry: FirEnumEntry, data: D): R  = visitElement(enumEntry, data)

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

@@ -36,6 +36,7 @@ import org.jetbrains.kotlin.fir.declarations.FirField
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 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.FirEnumEntry
 import org.jetbrains.kotlin.fir.declarations.FirFunction
@@ -240,6 +241,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(regularClass)
     }
 
+    open fun visitSealedClass(sealedClass: FirSealedClass) {
+        visitElement(sealedClass)
+    }
+
     open fun visitTypeAlias(typeAlias: FirTypeAlias) {
         visitElement(typeAlias)
     }
@@ -664,6 +669,10 @@ 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/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt

@@ -43,6 +43,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val klass = element("Class", Declaration, declaration, statement, annotationContainer)
     val classLikeDeclaration = element("ClassLikeDeclaration", Declaration, statement, memberDeclaration, symbolOwner, typeParametersOwner)
     val regularClass = element("RegularClass", Declaration, namedDeclaration, classLikeDeclaration, klass)
+    val sealedClass = element("SealedClass", Declaration, regularClass)
     val typeAlias = element("TypeAlias", Declaration, classLikeDeclaration)
     val enumEntry = element("EnumEntry", Declaration, regularClass)
 

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

@@ -61,12 +61,20 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
             kind = Interface
         }
 
-        impl(regularClass, "FirClassImpl") {
+        val modifiableRegularClass = impl(regularClass, "FirModifiableRegularClass") {
             parents += modifiableClass
             parents += modifiableTypeParametersOwner
+            kind = Interface
+        }
+
+        val regularClassConfig: ImplementationContext.() -> Unit = {
+            parents += modifiableRegularClass
             defaultNull("companionObject")
             defaultSupertypesComputationStatus()
         }
+        impl(regularClass, "FirClassImpl", regularClassConfig)
+
+        impl(sealedClass, config = regularClassConfig)
 
         impl(anonymousObject) {
             parents += modifiableClass

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

@@ -220,6 +220,10 @@ object NodeConfigurator : AbstractFieldConfigurator() {
             +superTypeRefs(withReplace = true)
         }
 
+        sealedClass.configure {
+            +fieldList("inheritors", classIdType, withReplace = true)
+        }
+
         typeAlias.configure {
             parentArg(classLikeDeclaration, "F", typeAlias)
             +symbol("FirTypeAliasSymbol")

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

@@ -289,7 +289,7 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
             }
         }
 
-        element.allFields.filter { it.type.contains("Symbol") }
+        element.allFields.filter { it.type.contains("Symbol") && it !is FieldList }
             .takeIf { it.isNotEmpty() && !isInterface && !element.type.contains("Reference")}
             ?.let { symbolFields ->
                 indent(1)
@@ -338,7 +338,7 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
                         }
 
                         else -> {
-                            if (type == "FirClassImpl" && field.name == "declarations") {
+                            if (type in setOf("FirClassImpl", "FirSealedClassImpl") && field.name == "declarations") {
                                 indent(2)
                                 println("(declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.forEach { it.accept(visitor, data) }")
                             }
@@ -413,7 +413,7 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
                     }
                     field.name in setOf("dispatchReceiver", "extensionReceiver") -> {
                     }
-                    type == "FirClassImpl" && field.name == "declarations" -> {
+                    type in setOf("FirClassImpl", "FirSealedClassImpl") && field.name == "declarations" -> {
                         indent(2)
                         println("(declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.transformInplace(transformer, data)")
                         indent(2)

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

@@ -59,3 +59,4 @@ val compositeTransformResultType = type("fir.visitors", "CompositeTransformResul
 val abstractFirBasedSymbolType = type("fir.symbols", "AbstractFirBasedSymbol")
 val backingFieldSymbolType = type("fir.symbols.impl", "FirBackingFieldSymbol")
 val delegateFieldSymbolType = type("fir.symbols.impl", "FirDelegateFieldSymbol")
+val classSymbolType = type("fir.symbols.impl", "FirClassSymbol")