Make FirClass a kind of FirClassLikeDeclaration, introduce FirRegularClass/AnonymousObject symbols

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt

@@ -133,7 +133,7 @@ private fun AbstractFirBasedSymbol<*>.toSymbol(declarationStorage: Fir2IrDeclara
     else -> null
 }
 
-fun FirClassSymbol.toClassSymbol(declarationStorage: Fir2IrDeclarationStorage): IrClassSymbol {
+fun FirClassSymbol<*>.toClassSymbol(declarationStorage: Fir2IrDeclarationStorage): IrClassSymbol {
     return declarationStorage.getIrClassSymbol(this)
 }
 

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCallableCache.kt

@@ -17,7 +17,7 @@ class Fir2IrCallableCache {
 
     private val variableCache = mutableMapOf<FirVariable<*>, IrVariable>()
 
-    private val localClassCache = mutableMapOf<FirClass, IrClass>()
+    private val localClassCache = mutableMapOf<FirClass<*>, IrClass>()
 
     private val localFunctionCache = mutableMapOf<FirFunction<*>, IrSimpleFunction>()
 
@@ -33,9 +33,9 @@ class Fir2IrCallableCache {
         variableCache[firVariable] = irVariable
     }
 
-    fun getLocalClass(localClass: FirClass): IrClass? = localClassCache[localClass]
+    fun getLocalClass(localClass: FirClass<*>): IrClass? = localClassCache[localClass]
 
-    fun putLocalClass(localClass: FirClass, irClass: IrClass) {
+    fun putLocalClass(localClass: FirClass<*>, irClass: IrClass) {
         require(localClass !is FirRegularClass || localClass.visibility == Visibilities.LOCAL)
         localClassCache[localClass] = irClass
     }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt

@@ -114,7 +114,7 @@ class Fir2IrDeclarationStorage(
         leaveScope(descriptor)
     }
 
-    private fun IrClass.declareSupertypesAndTypeParameters(klass: FirClass): IrClass {
+    private fun IrClass.declareSupertypesAndTypeParameters(klass: FirClass<*>): IrClass {
         for (superTypeRef in klass.superTypeRefs) {
             superTypes += superTypeRef.toIrType(session, this@Fir2IrDeclarationStorage)
         }
@@ -128,31 +128,33 @@ class Fir2IrDeclarationStorage(
         return this
     }
 
-    fun getIrClass(regularClass: FirRegularClass, setParent: Boolean = true): IrClass {
+    fun getIrClass(klass: FirClass<*>, setParent: Boolean = true): IrClass {
+        val regularClass = klass as? FirRegularClass
+
         fun create(): IrClass {
             val descriptor = WrappedClassDescriptor()
             val origin = IrDeclarationOrigin.DEFINED
-            val modality = regularClass.modality!!
+            val modality = regularClass?.modality ?: Modality.FINAL
-            return regularClass.convertWithOffsets { startOffset, endOffset ->
+            return klass.convertWithOffsets { startOffset, endOffset ->
                 irSymbolTable.declareClass(startOffset, endOffset, origin, descriptor, modality) { symbol ->
                     IrClassImpl(
                         startOffset,
                         endOffset,
                         origin,
                         symbol,
-                        regularClass.name,
+                        regularClass?.name ?: Name.special("<anonymous>"),
-                        regularClass.classKind,
+                        klass.classKind,
-                        regularClass.visibility,
+                        regularClass?.visibility ?: Visibilities.LOCAL,
                         modality,
-                        isCompanion = regularClass.isCompanion,
+                        isCompanion = regularClass?.isCompanion == true,
-                        isInner = regularClass.isInner,
+                        isInner = regularClass?.isInner == true,
-                        isData = regularClass.isData,
+                        isData = regularClass?.isData == true,
-                        isExternal = regularClass.isExternal,
+                        isExternal = regularClass?.isExternal == true,
-                        isInline = regularClass.isInline,
+                        isInline = regularClass?.isInline == true,
-                        isExpect = regularClass.isExpect
+                        isExpect = regularClass?.isExpect == true
                     ).apply {
                         descriptor.bind(this)
-                        if (setParent) {
+                        if (setParent && regularClass != null) {
                             val classId = regularClass.classId
                             val parentId = classId.outerClassId
                             if (parentId != null) {
@@ -172,16 +174,17 @@ class Fir2IrDeclarationStorage(
             }
         }
 
-        if (regularClass.visibility == Visibilities.LOCAL) {
+        if (regularClass?.visibility == Visibilities.LOCAL || klass is FirAnonymousObject) {
-            val cached = localStorage.getLocalClass(regularClass)
+            val cached = localStorage.getLocalClass(klass)
             if (cached != null) return cached
             val created = create()
-            localStorage.putLocalClass(regularClass, created)
+            localStorage.putLocalClass(klass, created)
-            created.declareSupertypesAndTypeParameters(regularClass)
+            created.declareSupertypesAndTypeParameters(klass)
             return created
         }
-        return classCache.getOrPut(regularClass, { create() }) {
+        // NB: klass can be either FirRegularClass or FirAnonymousObject
-            it.declareSupertypesAndTypeParameters(regularClass)
+        return classCache.getOrPut(klass as FirRegularClass, { create() }) {
+            it.declareSupertypesAndTypeParameters(klass)
         }
     }
 
@@ -617,7 +620,7 @@ class Fir2IrDeclarationStorage(
         }
     }
 
-    fun getIrClassSymbol(firClassSymbol: FirClassSymbol): IrClassSymbol {
+    fun getIrClassSymbol(firClassSymbol: FirClassSymbol<*>): IrClassSymbol {
         val irClass = getIrClass(firClassSymbol.fir)
         return irSymbolTable.referenceClass(irClass.descriptor)
     }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrLocalStorage.kt

@@ -43,7 +43,7 @@ class Fir2IrLocalStorage {
         return null
     }
 
-    fun getLocalClass(localClass: FirClass): IrClass? {
+    fun getLocalClass(localClass: FirClass<*>): IrClass? {
         for (cache in cacheStack.asReversed()) {
             val local = cache.getLocalClass(localClass)
             if (local != null) return local
@@ -67,7 +67,7 @@ class Fir2IrLocalStorage {
         cacheStack.last().putVariable(firVariable, irVariable)
     }
 
-    fun putLocalClass(firClass: FirClass, irClass: IrClass) {
+    fun putLocalClass(firClass: FirClass<*>, irClass: IrClass) {
         cacheStack.last().putLocalClass(firClass, irClass)
     }
 

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt

@@ -167,7 +167,7 @@ class Fir2IrVisitor(
             if (superType is ConeClassLikeType) {
                 when (val superSymbol = superType.lookupTag.toSymbol(this@Fir2IrVisitor.session)) {
                     is FirClassSymbol -> {
-                        val superClass = superSymbol.fir
+                        val superClass = superSymbol.fir as FirClass<*>
                         for (declaration in superClass.declarations) {
                             if (declaration is FirMemberDeclaration && (declaration is FirSimpleFunction || declaration is FirProperty)) {
                                 result += declaration.name
@@ -185,17 +185,17 @@ class Fir2IrVisitor(
         return result
     }
 
-    private fun FirClass.collectCallableNamesFromSupertypes(result: MutableList<Name> = mutableListOf()): List<Name> {
+    private fun FirClass<*>.collectCallableNamesFromSupertypes(result: MutableList<Name> = mutableListOf()): List<Name> {
         for (superTypeRef in superTypeRefs) {
             superTypeRef.collectCallableNamesFromThisAndSupertypes(result)
         }
         return result
     }
 
-    private fun FirClass.getPrimaryConstructorIfAny(): FirConstructor? =
+    private fun FirClass<*>.getPrimaryConstructorIfAny(): FirConstructor? =
         declarations.filterIsInstance<FirConstructor>().firstOrNull()?.takeIf { it.isPrimary }
 
-    private fun IrClass.addFakeOverrides(klass: FirClass, processedCallableNames: MutableList<Name>) {
+    private fun IrClass.addFakeOverrides(klass: FirClass<*>, processedCallableNames: MutableList<Name>) {
         if (fakeOverrideMode == FakeOverrideMode.NONE) return
         val superTypesCallableNames = klass.collectCallableNamesFromSupertypes()
         val useSiteMemberScope = (klass as? FirRegularClass)?.buildUseSiteMemberScope(session, ScopeSession()) ?: return
@@ -262,7 +262,7 @@ class Fir2IrVisitor(
         }
     }
 
-    private fun IrClass.setClassContent(klass: FirClass) {
+    private fun IrClass.setClassContent(klass: FirClass<*>) {
         declarationStorage.enterScope(descriptor)
         val primaryConstructor = klass.getPrimaryConstructorIfAny()
         val irPrimaryConstructor = primaryConstructor?.accept(this@Fir2IrVisitor, null) as IrConstructor?
@@ -341,7 +341,7 @@ class Fir2IrVisitor(
                     if (classLikeSymbol !is FirClassSymbol) {
                         lastClass
                     } else {
-                        val firClass = classLikeSymbol.fir
+                        val firClass = classLikeSymbol.fir as FirClass<*>
                         declarationStorage.getIrClass(firClass, setParent = false)
                     }
                 }
@@ -421,7 +421,7 @@ class Fir2IrVisitor(
     private fun FirDelegatedConstructorCall.toIrDelegatingConstructorCall(): IrDelegatingConstructorCall? {
         val constructedClassSymbol = with(typeContext) {
             (constructedTypeRef as FirResolvedTypeRef).type.typeConstructor()
-        } as? FirClassSymbol ?: return null
+        } as? FirClassSymbol<*> ?: return null
         val constructedIrType = constructedTypeRef.toIrType(this@Fir2IrVisitor.session, declarationStorage)
         // TODO: find delegated constructor correctly
         val classId = constructedClassSymbol.classId
@@ -709,7 +709,8 @@ class Fir2IrVisitor(
             when (symbol) {
                 is IrClassSymbol -> {
                     val irClass = symbol.owner
-                    val irConstructor = firSymbol?.fir?.getPrimaryConstructorIfAny()?.let { firConstructor ->
+                    val fir = firSymbol?.fir as? FirClass<*>
+                    val irConstructor = fir?.getPrimaryConstructorIfAny()?.let { firConstructor ->
                         declarationStorage.getIrConstructor(firConstructor, irParent = irClass, shouldLeaveScope = true)
                     }?.apply {
                         this.parent = irClass

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt

@@ -210,7 +210,7 @@ private fun ConeClassLikeType.toFirClass(session: FirSession): FirRegularClass?
     return when (this) {
         is ConeAbbreviatedType -> this.directExpansionType(session)?.toFirClass(session)
         else -> (this.lookupTag.toSymbol(session) as? FirClassSymbol)?.fir
-    }
+    } as? FirRegularClass
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt.183

@@ -211,7 +211,7 @@ private fun ConeClassLikeType.toFirClass(session: FirSession): FirRegularClass?
     return when (this) {
         is ConeAbbreviatedType -> this.directExpansionType(session)?.toFirClass(session)
         else -> (this.lookupTag.toSymbol(session) as? FirClassSymbol)?.fir
-    }
+    } as? FirRegularClass
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt

@@ -11,11 +11,8 @@ import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
-import org.jetbrains.kotlin.fir.declarations.addDefaultBoundIfNecessary
 import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
-import org.jetbrains.kotlin.fir.declarations.visibility
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
@@ -48,7 +45,7 @@ class JavaSymbolProvider(
     val session: FirSession,
     val project: Project,
     private val searchScope: GlobalSearchScope
-) : AbstractFirSymbolProvider() {
+) : AbstractFirSymbolProvider<FirRegularClassSymbol>() {
 
     private val facade: KotlinJavaPsiFacade get() = KotlinJavaPsiFacade.getInstance(project)
 
@@ -61,7 +58,7 @@ class JavaSymbolProvider(
         emptyList()
 
     override fun getClassDeclaredMemberScope(classId: ClassId): FirScope? {
-        val classSymbol = getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null
+        val classSymbol = getClassLikeSymbolByFqName(classId) ?: return null
         return declaredMemberScope(classSymbol.fir)
     }
 
@@ -70,18 +67,21 @@ class JavaSymbolProvider(
         useSiteSession: FirSession,
         scopeSession: ScopeSession
     ): FirScope? {
-        val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null
+        val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null
         return buildJavaEnhancementScope(useSiteSession, symbol, scopeSession, mutableSetOf())
     }
 
     private fun buildJavaEnhancementScope(
         useSiteSession: FirSession,
-        symbol: FirClassSymbol,
+        symbol: FirRegularClassSymbol,
         scopeSession: ScopeSession,
         visitedSymbols: MutableSet<FirClassLikeSymbol<*>>
     ): JavaClassEnhancementScope {
         return scopeSession.getOrBuild(symbol, JAVA_ENHANCEMENT) {
-            JavaClassEnhancementScope(useSiteSession, buildJavaUseSiteMemberScope(symbol.fir, useSiteSession, scopeSession, visitedSymbols))
+            JavaClassEnhancementScope(
+                useSiteSession,
+                buildJavaUseSiteMemberScope(symbol.fir, useSiteSession, scopeSession, visitedSymbols)
+            )
         }
     }
 
@@ -98,7 +98,7 @@ class JavaSymbolProvider(
                     .mapNotNull { useSiteSuperType ->
                         if (useSiteSuperType is ConeClassErrorType) return@mapNotNull null
                         val symbol = useSiteSuperType.lookupTag.toSymbol(useSiteSession)
-                        if (symbol is FirClassSymbol && visitedSymbols.add(symbol)) {
+                        if (symbol is FirRegularClassSymbol && visitedSymbols.add(symbol)) {
                             // We need JavaClassEnhancementScope here to have already enhanced signatures from supertypes
                             val scope = buildJavaEnhancementScope(useSiteSession, symbol, scopeSession, visitedSymbols)
                             visitedSymbols.remove(symbol)
@@ -151,16 +151,16 @@ class JavaSymbolProvider(
             }
     }
 
-    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? = getFirJavaClass(classId)
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirRegularClassSymbol? = getFirJavaClass(classId)
 
-    fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): FirClassLikeSymbol<*>? {
+    fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): FirRegularClassSymbol? {
         if (!hasTopLevelClassOf(classId)) return null
         return classCache.lookupCacheOrCalculateWithPostCompute(classId, {
             val foundClass = findClass(classId, content)
             if (foundClass == null || foundClass.annotations.any { it.classId?.asSingleFqName() == JvmAnnotationNames.METADATA_FQ_NAME }) {
                 null to null
             } else {
-                FirClassSymbol(classId) to foundClass
+                FirRegularClassSymbol(classId) to foundClass
             }
         }) { firSymbol, foundClass ->
             foundClass?.let { javaClass ->
@@ -169,7 +169,7 @@ class JavaSymbolProvider(
                 val isTopLevel = parentFqName.isRoot
                 if (!isTopLevel) {
                     val parentId = ClassId(classId.packageFqName, parentFqName, false)
-                    val parentClassSymbol = getClassLikeSymbolByFqName(parentId) as? FirClassSymbol
+                    val parentClassSymbol = getClassLikeSymbolByFqName(parentId)
                     val parentClass = parentClassSymbol?.fir
                     if (parentClass is FirJavaClass) {
                         javaTypeParameterStack.addStack(parentClass.javaTypeParameterStack)
@@ -177,7 +177,7 @@ class JavaSymbolProvider(
                 }
                 FirJavaClass(
                     (javaClass as? JavaElementImpl<*>)?.psi?.toFirSourceElement(), session,
-                    firSymbol as FirClassSymbol, javaClass.name,
+                    firSymbol, javaClass.name,
                     javaClass.visibility, javaClass.modality,
                     javaClass.classKind, isTopLevel = isTopLevel,
                     isStatic = javaClass.isStatic,
@@ -291,7 +291,7 @@ class JavaSymbolProvider(
 
     fun getJavaTopLevelClasses(): List<FirRegularClass> {
         return classCache.values
-            .filterIsInstance<FirClassSymbol>()
+            .filterIsInstance<FirRegularClassSymbol>()
             .filter { it.classId.relativeClassName.parent().isRoot }
             .map { it.fir }
     }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.getClassDeclaredCallableSymbols
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.toFirSourceElement
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
@@ -178,7 +178,7 @@ internal fun JavaAnnotation.toFirAnnotationCall(
         source = null, useSiteTarget = null,
         annotationTypeRef = FirResolvedTypeRefImpl(
             source = null,
-            type = ConeClassTypeImpl(FirClassSymbol(classId!!).toLookupTag(), emptyArray(), isNullable = false)
+            type = ConeClassTypeImpl(FirRegularClassSymbol(classId!!).toLookupTag(), emptyArray(), isNullable = false)
         )
     ).apply {
         for (argument in this@toFirAnnotationCall.arguments) {

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.name.Name
 class FirJavaClass internal constructor(
     override val source: FirSourceElement?,
     override val session: FirSession,
-    override val symbol: FirClassSymbol,
+    override val symbol: FirRegularClassSymbol,
     override val name: Name,
     visibility: Visibility,
     modality: Modality?,
@@ -35,7 +35,7 @@ class FirJavaClass internal constructor(
     isTopLevel: Boolean,
     isStatic: Boolean,
     internal val javaTypeParameterStack: JavaTypeParameterStack
-) : FirPureAbstractElement(), FirRegularClass, FirModifiableClass {
+) : FirPureAbstractElement(), FirRegularClass, FirModifiableClass<FirRegularClass> {
     override var status: FirDeclarationStatusImpl = FirDeclarationStatusImpl(visibility, modality)
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
@@ -80,7 +80,7 @@ class FirJavaClass internal constructor(
         superTypeRefs.forEach { it.accept(visitor, data) }
     }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableClass {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirJavaClass {
         declarations.transformInplace(transformer, data)
         annotations.transformInplace(transformer, data)
         typeParameters.transformInplace(transformer, data)

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt

@@ -57,8 +57,8 @@ class KotlinDeserializedJvmSymbolsProvider(
     private val javaSymbolProvider: JavaSymbolProvider,
     private val kotlinClassFinder: KotlinClassFinder,
     private val javaClassFinder: JavaClassFinder
-) : AbstractFirSymbolProvider() {
+) : AbstractFirSymbolProvider<FirClassLikeSymbol<*>>() {
-    private val classesCache = HashMap<ClassId, FirClassSymbol>()
+    private val classesCache = HashMap<ClassId, FirRegularClassSymbol>()
     private val typeAliasCache = HashMap<ClassId, FirTypeAliasSymbol?>()
     private val packagePartsCache = HashMap<FqName, Collection<PackagePartsCacheData>>()
 
@@ -142,7 +142,7 @@ class KotlinDeserializedJvmSymbolsProvider(
     ): FirScope? {
         val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null
 
-        return symbol.fir.buildDefaultUseSiteMemberScope(session, scopeSession)
+        return (symbol.fir as FirClass<*>).buildDefaultUseSiteMemberScope(session, scopeSession)
     }
 
     override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? {
@@ -304,7 +304,7 @@ class KotlinDeserializedJvmSymbolsProvider(
     private fun findAndDeserializeClass(
         classId: ClassId,
         parentContext: FirDeserializationContext? = null
-    ): FirClassSymbol? {
+    ): FirRegularClassSymbol? {
         if (!hasTopLevelClassOf(classId)) return null
         if (classesCache.containsKey(classId)) return classesCache[classId]
 
@@ -314,7 +314,7 @@ class KotlinDeserializedJvmSymbolsProvider(
             is KotlinClassFinder.Result.KotlinClass -> result.kotlinJvmBinaryClass
             is KotlinClassFinder.Result.ClassFileContent -> {
                 handledByJava.add(classId)
-                return javaSymbolProvider.getFirJavaClass(classId, result) as FirClassSymbol?
+                return javaSymbolProvider.getFirJavaClass(classId, result)
             }
             null -> null
         }
@@ -325,7 +325,7 @@ class KotlinDeserializedJvmSymbolsProvider(
             if (kotlinJvmBinaryClass.classHeader.kind != KotlinClassHeader.Kind.CLASS) return null
             val (nameResolver, classProto) = kotlinJvmBinaryClass.readClassDataFrom() ?: return null
 
-            val symbol = FirClassSymbol(classId)
+            val symbol = FirRegularClassSymbol(classId)
             deserializeClassToSymbol(
                 classId, classProto, symbol, nameResolver, session,
                 JvmBinaryAnnotationDeserializer(session),

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.load.java.*
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME
 import org.jetbrains.kotlin.load.java.lazy.NullabilityQualifierWithApplicability
@@ -51,7 +51,7 @@ class FirAnnotationTypeQualifierResolver(private val session: FirSession, privat
     }
 
     private val FirAnnotationCall.resolvedClass: FirRegularClass?
-        get() = (coneClassLikeType?.lookupTag?.toSymbol(this@FirAnnotationTypeQualifierResolver.session) as? FirClassSymbol)?.fir
+        get() = (coneClassLikeType?.lookupTag?.toSymbol(this@FirAnnotationTypeQualifierResolver.session) as? FirRegularClassSymbol)?.fir
 
     fun resolveTypeQualifierAnnotation(annotationCall: FirAnnotationCall): FirAnnotationCall? {
         if (jsr305State.disabled) {

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt

@@ -379,7 +379,7 @@ class DeclarationsConverter(
                     className,
                     status,
                     classKind,
-                    FirClassSymbol(context.currentClassId)
+                    FirRegularClassSymbol(context.currentClassId)
                 )
             } else {
                 FirClassImpl(
@@ -388,7 +388,7 @@ class DeclarationsConverter(
                     className,
                     status,
                     classKind,
-                    FirClassSymbol(context.currentClassId)
+                    FirRegularClassSymbol(context.currentClassId)
                 )
             }
             firClass.annotations += modifiers.annotations
@@ -464,7 +464,7 @@ class DeclarationsConverter(
         superTypeRefs.ifEmpty { superTypeRefs += implicitAnyType }
         val delegatedType = delegatedSuperTypeRef ?: implicitAnyType
 
-        return FirAnonymousObjectImpl(null, session).apply {
+        return FirAnonymousObjectImpl(null, session, FirAnonymousObjectSymbol()).apply {
             annotations += modifiers.annotations
             this.superTypeRefs += superTypeRefs
             this.typeRef = superTypeRefs.first()
@@ -514,7 +514,7 @@ class DeclarationsConverter(
                 null,
                 session,
                 enumEntryName,
-                FirClassSymbol(context.currentClassId)
+                FirRegularClassSymbol(context.currentClassId)
             )
             firEnumEntry.annotations += modifiers.annotations
 

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

@@ -317,7 +317,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         }
 
         private fun KtClassOrObject.extractSuperTypeListEntriesTo(
-            container: FirModifiableClass, delegatedSelfTypeRef: FirTypeRef?
+            container: FirModifiableClass<*>, delegatedSelfTypeRef: FirTypeRef?
         ): FirTypeRef? {
             var superTypeCallEntry: KtSuperTypeCallEntry? = null
             var delegatedSuperTypeRef: FirTypeRef? = null
@@ -439,7 +439,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                     enumEntry.toFirSourceElement(),
                     session,
                     enumEntry.nameAsSafeName,
-                    FirClassSymbol(context.currentClassId)
+                    FirRegularClassSymbol(context.currentClassId)
                 )
                 enumEntry.extractAnnotationsTo(firEnumEntry)
                 val delegatedSelfType = enumEntry.toDelegatedSelfType(firEnumEntry)
@@ -486,7 +486,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                         classOrObject.nameAsSafeName,
                         status,
                         classKind,
-                        FirClassSymbol(context.currentClassId)
+                        FirRegularClassSymbol(context.currentClassId)
                     )
                 } else {
                     FirClassImpl(
@@ -495,7 +495,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                         classOrObject.nameAsSafeName,
                         status,
                         classKind,
-                        FirClassSymbol(context.currentClassId)
+                        FirRegularClassSymbol(context.currentClassId)
                     )
                 }
                 classOrObject.extractAnnotationsTo(firClass)
@@ -538,7 +538,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitObjectLiteralExpression(expression: KtObjectLiteralExpression, data: Unit): FirElement {
             val objectDeclaration = expression.objectDeclaration
-            return FirAnonymousObjectImpl(expression.toFirSourceElement(), session).apply {
+            return FirAnonymousObjectImpl(expression.toFirSourceElement(), session, FirAnonymousObjectSymbol()).apply {
                 objectDeclaration.extractAnnotationsTo(this)
                 objectDeclaration.extractSuperTypeListEntriesTo(this, null)
                 this.typeRef = superTypeRefs.first() // TODO

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.resolve.constructType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
@@ -70,7 +71,7 @@ abstract class AbstractAnnotationDeserializer(
         val classId = nameResolver.getClassId(proto.id)
         val lookupTag = ConeClassLikeLookupTagImpl(classId)
         val symbol = lookupTag.toSymbol(session)
-        val firAnnotationClass = (symbol as? FirClassSymbol)?.fir
+        val firAnnotationClass = (symbol as? FirRegularClassSymbol)?.fir
 
         var arguments = emptyList<FirExpression>()
         if (proto.argumentCount != 0 && firAnnotationClass?.classKind == ClassKind.ANNOTATION_CLASS) {

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

@@ -15,6 +15,7 @@ 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.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.metadata.ProtoBuf
@@ -30,12 +31,12 @@ import org.jetbrains.kotlin.serialization.deserialization.getName
 fun deserializeClassToSymbol(
     classId: ClassId,
     classProto: ProtoBuf.Class,
-    symbol: FirClassSymbol,
+    symbol: FirRegularClassSymbol,
     nameResolver: NameResolver,
     session: FirSession,
     defaultAnnotationDeserializer: AbstractAnnotationDeserializer?,
     parentContext: FirDeserializationContext? = null,
-    deserializeNestedClass: (ClassId, FirDeserializationContext) -> FirClassSymbol?
+    deserializeNestedClass: (ClassId, FirDeserializationContext) -> FirRegularClassSymbol?
 ) {
     val flags = classProto.flags
     val kind = Flags.CLASS_KIND.get(flags)
@@ -119,7 +120,7 @@ fun deserializeClassToSymbol(
                 val enumEntryName = nameResolver.getName(enumEntryProto.name)
                 val enumEntryId = classId.createNestedClassId(enumEntryName)
 
-                val symbol = FirClassSymbol(enumEntryId)
+                val symbol = FirRegularClassSymbol(enumEntryId)
                 FirEnumEntryImpl(null, session, enumEntryId.shortClassName, symbol).apply {
                     resolvePhase = FirResolvePhase.DECLARATIONS
                     superTypeRefs += FirResolvedTypeRefImpl(

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.deserialization
 
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
 import org.jetbrains.kotlin.fir.declarations.addDefaultBoundIfNecessary
 import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
 import org.jetbrains.kotlin.fir.resolve.toTypeProjection
@@ -109,7 +110,8 @@ class FirTypeDeserializer(
         get() = typeParameterDescriptors.values.toList()
 
 
-    fun FirClassLikeSymbol<*>.typeParameters(): List<FirTypeParameterSymbol> = fir.typeParameters.map { it.symbol }
+    fun FirClassLikeSymbol<*>.typeParameters(): List<FirTypeParameterSymbol> =
+        (fir as? FirTypeParametersOwner)?.typeParameters?.map { it.symbol }.orEmpty()
 
     fun simpleType(proto: ProtoBuf.Type): ConeLookupTagBasedType? {
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/AbstractFirSymbolProvider.kt

@@ -5,17 +5,14 @@
 
 package org.jetbrains.kotlin.fir.resolve
 
-import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 
-abstract class AbstractFirSymbolProvider : FirSymbolProvider() {
+abstract class AbstractFirSymbolProvider<C : FirClassLikeSymbol<*>> : FirSymbolProvider() {
-    protected val classCache = HashMap<ClassId, FirClassLikeSymbol<*>?>()
+    protected val classCache = HashMap<ClassId, C?>()
     protected val topLevelCallableCache = HashMap<CallableId, List<FirCallableSymbol<*>>>()
     protected val packageCache = HashMap<FqName, FqName?>()
 
@@ -29,15 +26,15 @@ abstract class AbstractFirSymbolProvider : FirSymbolProvider() {
         }
     }
 
-    protected inline fun <K, V : Any?, T> MutableMap<K, V>.lookupCacheOrCalculateWithPostCompute(
+    protected inline fun <K, V : Any, T> MutableMap<K, V?>.lookupCacheOrCalculateWithPostCompute(
-        key: K, crossinline l: (K) -> Pair<V, T>, postCompute: (V, T) -> Unit
+        key: K, crossinline l: (K) -> Pair<V?, T>, postCompute: (V, T) -> Unit
     ): V? {
         return if (containsKey(key)) {
             this[key]
         } else {
             val calculated = l(key)
             this[key] = calculated.first
-            postCompute(calculated.first, calculated.second)
+            calculated.first?.let { first -> postCompute(first, calculated.second) }
             calculated.first
         }
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -47,6 +47,9 @@ val FirSession.correspondingSupertypesCache: FirCorrespondingSupertypesCache by
 val FirSession.memberScopeProvider: FirMemberScopeProvider by componentArrayAccessor()
 
 fun ConeClassLikeLookupTag.toSymbol(useSiteSession: FirSession): FirClassLikeSymbol<*>? {
+    if (this is ConeClassLookupTagWithFixedSymbol) {
+        return this.symbol
+    }
     val firSymbolProvider = useSiteSession.firSymbolProvider
     return firSymbolProvider.getSymbolByLookupTag(this)
 }
@@ -96,7 +99,7 @@ fun ConeClassifierLookupTag.toSymbol(useSiteSession: FirSession): FirClassifierS
 
 fun ConeTypeParameterLookupTag.toSymbol(): FirTypeParameterSymbol = this.symbol as FirTypeParameterSymbol
 
-fun ConeClassLikeLookupTag.constructClassType(typeArguments: Array<ConeKotlinTypeProjection>, isNullable: Boolean): ConeLookupTagBasedType {
+fun ConeClassLikeLookupTag.constructClassType(typeArguments: Array<out ConeKotlinTypeProjection>, isNullable: Boolean): ConeLookupTagBasedType {
     return ConeClassTypeImpl(this, typeArguments, isNullable)
 }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt

@@ -20,10 +20,7 @@ import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
@@ -217,7 +214,7 @@ private fun FirRegularClass.computeSamCandidateNames(session: FirSession): Set<N
     val classes =
         lookupSuperTypes(this, lookupInterfaces = true, deep = true, useSiteSession = session)
             .mapNotNullTo(mutableListOf(this)) {
-                (session.firSymbolProvider.getSymbolByLookupTag(it.lookupTag) as? FirClassSymbol)?.fir
+                (session.firSymbolProvider.getSymbolByLookupTag(it.lookupTag) as? FirRegularClassSymbol)?.fir
             }
 
     val samCandidateNames = mutableSetOf<Name>()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt

@@ -13,14 +13,11 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassUseSiteMemberScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
 
 fun lookupSuperTypes(
-    klass: FirRegularClass,
+    klass: FirClass<*>,
     lookupInterfaces: Boolean,
     deep: Boolean,
     useSiteSession: FirSession
@@ -51,6 +48,13 @@ val USE_SITE = scopeSessionKey<FirScope>()
 
 data class SubstitutionScopeKey(val type: ConeClassLikeType) : ScopeSessionKey<FirClassSubstitutionScope>() {}
 
+fun FirClassSymbol<*>.buildUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? {
+    when (this) {
+        is FirAnonymousObjectSymbol -> return fir.buildDefaultUseSiteMemberScope(useSiteSession, builder)
+        is FirRegularClassSymbol -> return fir.buildUseSiteMemberScope(useSiteSession, builder)
+    }
+}
+
 fun FirRegularClass.buildUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope? {
     if (classId.isLocal) {
         // It's not possible to find local class by symbol
@@ -67,7 +71,7 @@ fun FirTypeAlias.buildUseSiteMemberScope(useSiteSession: FirSession, builder: Sc
     }
 }
 
-fun FirRegularClass.buildDefaultUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope {
+fun FirClass<*>.buildDefaultUseSiteMemberScope(useSiteSession: FirSession, builder: ScopeSession): FirScope {
     return builder.getOrBuild(symbol, USE_SITE) {
 
         val declaredScope = declaredMemberScope(this)
@@ -75,7 +79,7 @@ fun FirRegularClass.buildDefaultUseSiteMemberScope(useSiteSession: FirSession, b
             .mapNotNull { useSiteSuperType ->
                 if (useSiteSuperType is ConeClassErrorType) return@mapNotNull null
                 val symbol = useSiteSuperType.lookupTag.toSymbol(useSiteSession)
-                if (symbol is FirClassSymbol) {
+                if (symbol is FirRegularClassSymbol) {
                     val useSiteMemberScope = symbol.fir.buildUseSiteMemberScope(useSiteSession, builder)!!
                     useSiteSuperType.wrapSubstitutionScopeIfNeed(useSiteSession, useSiteMemberScope, symbol.fir, builder)
                 } else {
@@ -94,8 +98,9 @@ fun ConeClassLikeType.wrapSubstitutionScopeIfNeed(
 ): FirScope {
     if (this.typeArguments.isEmpty()) return useSiteMemberScope
     return builder.getOrBuild(declaration.symbol, SubstitutionScopeKey(this)) {
+        val typeParameters = (declaration as? FirTypeParametersOwner)?.typeParameters.orEmpty()
         @Suppress("UNCHECKED_CAST")
-        val substitution = declaration.typeParameters.zip(this.typeArguments) { typeParameter, typeArgument ->
+        val substitution = typeParameters.zip(this.typeArguments) { typeParameter, typeArgument ->
             typeParameter.symbol to (typeArgument as? ConeTypedProjection)?.type
         }.filter { (_, type) -> type != null }.toMap() as Map<FirTypeParameterSymbol, ConeKotlinType>
 
@@ -121,7 +126,7 @@ private fun FirClassifierSymbol<*>.collectSuperTypes(
     when (this) {
         is FirClassSymbol -> {
             val superClassTypes =
-                fir.superConeTypes.mapNotNull {
+                superConeTypes.mapNotNull {
                     it.computePartialExpansion(useSiteSession)
                         .takeIf { type -> lookupInterfaces || type.isClassBasedType(useSiteSession) }
                 }
@@ -149,5 +154,11 @@ private fun FirClassifierSymbol<*>.collectSuperTypes(
 
 private fun ConeClassLikeType?.isClassBasedType(
     useSiteSession: FirSession
-) = this !is ConeClassErrorType &&
+): Boolean {
-        (this?.lookupTag?.toSymbol(useSiteSession) as? FirClassSymbol)?.fir?.classKind == ClassKind.CLASS
+    if (this is ConeClassErrorType) return false
+    val symbol = this?.lookupTag?.toSymbol(useSiteSession) as? FirClassSymbol ?: return false
+    return when (symbol) {
+        is FirAnonymousObjectSymbol -> true
+        is FirRegularClassSymbol -> symbol.fir.classKind == ClassKind.CLASS
+    }
+}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt

@@ -6,6 +6,8 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
 import org.jetbrains.kotlin.fir.declarations.classId
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirThisReceiverExpressionImpl
@@ -37,10 +39,10 @@ private fun receiverExpression(symbol: AbstractFirBasedSymbol<*>, type: ConeKotl
         typeRef = FirResolvedTypeRefImpl(null, type)
     }
 
-class ClassDispatchReceiverValue(val klassSymbol: FirClassSymbol) : ReceiverValue {
+class ClassDispatchReceiverValue(val klassSymbol: FirClassSymbol<*>) : ReceiverValue {
     override val type: ConeKotlinType = ConeClassTypeImpl(
         klassSymbol.toLookupTag(),
-        klassSymbol.fir.typeParameters.map { ConeStarProjection }.toTypedArray(),
+        (klassSymbol.fir as? FirTypeParametersOwner)?.typeParameters?.map { ConeStarProjection }?.toTypedArray().orEmpty(),
         isNullable = false
     )
 
@@ -86,13 +88,13 @@ abstract class ImplicitReceiverValue<S : AbstractFirBasedSymbol<*>>(
 }
 
 class ImplicitDispatchReceiverValue(
-    boundSymbol: FirClassSymbol,
+    boundSymbol: FirClassSymbol<*>,
     type: ConeKotlinType,
     symbolProvider: FirSymbolProvider,
     useSiteSession: FirSession,
     scopeSession: ScopeSession
-) : ImplicitReceiverValue<FirClassSymbol>(boundSymbol, type, useSiteSession, scopeSession) {
+) : ImplicitReceiverValue<FirClassSymbol<*>>(boundSymbol, type, useSiteSession, scopeSession) {
-    val implicitCompanionScope: FirScope? = boundSymbol.fir.companionObject?.let { companionObject ->
+    val implicitCompanionScope: FirScope? = (boundSymbol.fir as? FirRegularClass)?.companionObject?.let { companionObject ->
         val companionId = companionObject.classId
         if (companionId.isLocal) {
             companionObject.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirTowerResolver.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.isInner
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.calls.TowerDataKind.EMPTY
@@ -110,7 +111,7 @@ class FirTowerResolver(
                 if (blockDispatchReceivers) {
                     continue
                 }
-                if (!implicitDispatchReceiverValue.boundSymbol.fir.isInner) {
+                if ((implicitDispatchReceiverValue.boundSymbol.fir as? FirRegularClass)?.isInner == false) {
                     blockDispatchReceivers = true
                 }
             }
@@ -192,7 +193,7 @@ class FirTowerResolver(
                     // }
                     towerDataConsumer.consume(TOWER_LEVEL, ScopeTowerLevel(session, components, implicitCompanionScope), group++)
                 }
-                if (!implicitReceiverValue.boundSymbol.fir.isInner) {
+                if ((implicitReceiverValue.boundSymbol.fir as? FirRegularClass)?.isInner == false) {
                     blockDispatchReceivers = true
                 }
             }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TowerLevels.kt

@@ -67,7 +67,7 @@ abstract class SessionBasedTowerLevel(val session: FirSession) : TowerScopeLevel
             is FirNamedFunctionSymbol -> fir.dispatchReceiverValue(session)
             is FirPropertySymbol -> fir.dispatchReceiverValue(session)
             is FirFieldSymbol -> fir.dispatchReceiverValue(session)
-            is FirClassSymbol -> ClassDispatchReceiverValue(fir.symbol)
+            is FirClassSymbol -> ClassDispatchReceiverValue(this)
             else -> null
         }
     }
@@ -263,9 +263,8 @@ fun FirCallableDeclaration<*>.dispatchReceiverValue(session: FirSession): ClassD
     if (this is FirConstructor) return null
     val id = this.symbol.callableId.classId ?: return null
     val symbol = session.firSymbolProvider.getClassLikeSymbolByFqName(id) as? FirClassSymbol ?: return null
-    val regularClass = symbol.fir
 
-    return ClassDispatchReceiverValue(regularClass.symbol)
+    return ClassDispatchReceiverValue(symbol)
 }
 
 private fun FirCallableSymbol<*>.hasExtensionReceiver(): Boolean = this.fir.receiverTypeRef != null
@@ -333,7 +332,7 @@ private fun processSyntheticConstructors(
     bodyResolveComponents: BodyResolveComponents
 ): ProcessorAction {
     if (matchedSymbol == null) return ProcessorAction.NEXT
-    if (matchedSymbol !is FirClassSymbol) return ProcessorAction.NEXT
+    if (matchedSymbol !is FirRegularClassSymbol) return ProcessorAction.NEXT
 
     val function = bodyResolveComponents.samResolver.getSamConstructor(matchedSymbol.fir) ?: return ProcessorAction.NEXT
 
@@ -351,7 +350,7 @@ private fun processConstructors(
         if (matchedSymbol != null) {
             val scope = when (matchedSymbol) {
                 is FirTypeAliasSymbol -> matchedSymbol.fir.buildUseSiteMemberScope(session, scopeSession)
-                is FirClassSymbol -> matchedSymbol.fir.buildUseSiteMemberScope(session, scopeSession)
+                is FirClassSymbol -> matchedSymbol.buildUseSiteMemberScope(session, scopeSession)
             }
 
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirDependenciesSymbolProviderImpl.kt

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 
-class FirDependenciesSymbolProviderImpl(val session: FirSession) : AbstractFirSymbolProvider() {
+class FirDependenciesSymbolProviderImpl(val session: FirSession) : AbstractFirSymbolProvider<FirClassLikeSymbol<*>>() {
     private val dependencyProviders by lazy {
         val moduleInfo = session.moduleInfo ?: return@lazy emptyList()
         moduleInfo.dependenciesWithoutSelf().mapNotNull {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirLibrarySymbolProviderImpl.kt

@@ -72,15 +72,15 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
             ).memberDeserializer
         }
 
-        val lookup = mutableMapOf<ClassId, FirClassSymbol>()
+        val lookup = mutableMapOf<ClassId, FirRegularClassSymbol>()
 
-        fun getClassLikeSymbolByFqName(classId: ClassId): FirClassSymbol? =
+        fun getClassLikeSymbolByFqName(classId: ClassId): FirRegularClassSymbol? =
             findAndDeserializeClass(classId)
 
         private fun findAndDeserializeClass(
             classId: ClassId,
             parentContext: FirDeserializationContext? = null
-        ): FirClassSymbol? {
+        ): FirRegularClassSymbol? {
             val classIdExists = classId in classDataFinder.allClassIds
             val shouldBeEnumEntry = !classIdExists && classId.outerClassId in classDataFinder.allClassIds
             if (!classIdExists && !shouldBeEnumEntry) return null
@@ -91,7 +91,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
                     return null
                 }
             }
-            return lookup.getOrPut(classId, { FirClassSymbol(classId) }) { symbol ->
+            return lookup.getOrPut(classId, { FirRegularClassSymbol(classId) }) { symbol ->
                 if (shouldBeEnumEntry) {
                     FirEnumEntryImpl(null, session, classId.shortClassName, symbol).apply {
                         resolvePhase = FirResolvePhase.DECLARATIONS
@@ -152,9 +152,9 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
 
     private val allPackageFragments = loadBuiltIns().groupBy { it.fqName }
 
-    private val fictitiousFunctionSymbols = mutableMapOf<Int, FirClassSymbol>()
+    private val fictitiousFunctionSymbols = mutableMapOf<Int, FirRegularClassSymbol>()
 
-    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassSymbol? {
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirRegularClassSymbol? {
         return allPackageFragments[classId.packageFqName]?.firstNotNullResult {
             it.getClassLikeSymbolByFqName(classId)
         } ?: with(classId) {
@@ -171,7 +171,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
                     isData = false
                     isInline = false
                 }
-                FirClassSymbol(this).apply {
+                FirRegularClassSymbol(this).apply {
                     FirClassImpl(
                         null,
                         session,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirProviderImpl.kt

@@ -16,10 +16,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassDeclaredMemberScope
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid
@@ -219,7 +216,8 @@ class FirProviderImpl(val session: FirSession) : FirProvider() {
         scopeSession: ScopeSession
     ): FirScope? {
         return when (val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null) {
-            is FirClassSymbol -> symbol.fir.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession)
+            is FirRegularClassSymbol -> symbol.fir.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession)
+            is FirAnonymousObjectSymbol -> symbol.fir.buildDefaultUseSiteMemberScope(useSiteSession, scopeSession)
             is FirTypeAliasSymbol -> {
                 val expandedTypeRef = symbol.fir.expandedTypeRef as FirResolvedTypeRef
                 val expandedType = expandedTypeRef.type as? ConeLookupTagBasedType ?: return null

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

@@ -5,10 +5,7 @@
 
 package org.jetbrains.kotlin.fir.resolve.transformers
 
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.isCompanion
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
 import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope

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

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
@@ -81,7 +82,7 @@ class FirSealedClassInheritorsTransformer : FirTransformer<Nothing?>() {
             val lookupTag = ((typeRef as FirResolvedTypeRef).type as? ConeLookupTagBasedType)?.lookupTag ?: return null
             val classLikeSymbol: FirClassifierSymbol<*> = symbolProvider.getSymbolByLookupTag(lookupTag) ?: return null
             return when (classLikeSymbol) {
-                is FirClassSymbol -> classLikeSymbol.fir
+                is FirRegularClassSymbol -> classLikeSymbol.fir
                 is FirTypeAliasSymbol -> extractClassFromTypeRef(symbolProvider, classLikeSymbol.fir.expandedTypeRef)
                 else -> null
             }

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

@@ -144,8 +144,8 @@ class FirWhenExhaustivenessTransformer(private val bodyResolveComponents: BodyRe
 
         override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: SealedExhaustivenessData) {
             val lookupTag = (resolvedTypeRef.type as? ConeLookupTagBasedType)?.lookupTag ?: return
-            val klass = (data.symbolProvider.getSymbolByLookupTag(lookupTag) as? FirClassSymbol)?.fir ?: return
+            val symbol = data.symbolProvider.getSymbolByLookupTag(lookupTag) as? FirClassSymbol ?: return
-            data.visitedInheritors.replace(klass.symbol.classId, true)
+            data.visitedInheritors.replace(symbol.classId, true)
         }
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve
 
 import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.FirCallResolver
+import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionWithSmartcastImpl
@@ -346,7 +347,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                     val symbol = symbolProvider.getClassLikeSymbolByFqName(classId)
                     // TODO: Unify logic?
                     symbol?.constructType(
-                        Array(symbol.phasedFir.typeParameters.size) {
+                        Array((symbol.phasedFir as? FirTypeParametersOwner)?.typeParameters?.size ?: 0) {
                             ConeStarProjection
                         },
                         isNullable = false

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.scopes.FirScope
@@ -18,15 +19,18 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
-class FirClassDeclaredMemberScope(klass: FirRegularClass) : FirScope() {
+class FirClassDeclaredMemberScope(klass: FirClass<*>) : FirScope() {
     private val nestedClassifierScope = nestedClassifierScope(klass)
 
     private val callablesIndex: Map<Name, List<FirCallableSymbol<*>>> = run {
         val result = mutableMapOf<Name, MutableList<FirCallableSymbol<*>>>()
-        for (declaration in klass.declarations) {
+        loop@ for (declaration in klass.declarations) {
             when (declaration) {
                 is FirCallableMemberDeclaration<*> -> {
-                    val name = if (declaration is FirConstructor) klass.name else declaration.name
+                    val name = when (declaration) {
+                        is FirConstructor -> if (klass is FirRegularClass) klass.name else continue@loop
+                        else -> declaration.name
+                    }
                     result.getOrPut(name) { mutableListOf() } += declaration.symbol
                 }
                 is FirRegularClass -> {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirLocalScope.kt

@@ -16,7 +16,7 @@ class FirLocalScope : FirScope() {
 
     val properties = mutableMapOf<Name, FirVariableSymbol<*>>()
     val functions = mutableMapOf<Name, FirFunctionSymbol<*>>()
-    val classes = mutableMapOf<Name, FirClassSymbol>()
+    val classes = mutableMapOf<Name, FirRegularClassSymbol>()
 
     fun storeDeclaration(declaration: FirNamedDeclaration) {
         when (declaration) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirMemberScopeProvider.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
+import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.resolve.memberScopeProvider
 import org.jetbrains.kotlin.name.ClassId
@@ -14,17 +15,17 @@ import org.jetbrains.kotlin.name.FqName
 
 class FirMemberScopeProvider : FirSessionComponent {
 
-    private val declaredMemberCache = mutableMapOf<FirRegularClass, FirClassDeclaredMemberScope>()
+    private val declaredMemberCache = mutableMapOf<FirClass<*>, FirClassDeclaredMemberScope>()
-    private val nestedClassifierCache = mutableMapOf<FirRegularClass, FirNestedClassifierScope>()
+    private val nestedClassifierCache = mutableMapOf<FirClass<*>, FirNestedClassifierScope>()
     private val selfImportingCache = mutableMapOf<FqName, FirSelfImportingScope>()
 
-    fun declaredMemberScope(klass: FirRegularClass): FirClassDeclaredMemberScope {
+    fun declaredMemberScope(klass: FirClass<*>): FirClassDeclaredMemberScope {
         return declaredMemberCache.getOrPut(klass) {
             FirClassDeclaredMemberScope(klass)
         }
     }
 
-    fun nestedClassifierScope(klass: FirRegularClass): FirNestedClassifierScope {
+    fun nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope {
         return nestedClassifierCache.getOrPut(klass) {
             FirNestedClassifierScope(klass)
         }
@@ -38,14 +39,14 @@ class FirMemberScopeProvider : FirSessionComponent {
     }
 }
 
-fun declaredMemberScope(klass: FirRegularClass): FirClassDeclaredMemberScope {
+fun declaredMemberScope(klass: FirClass<*>): FirClassDeclaredMemberScope {
     return klass
         .session
         .memberScopeProvider
         .declaredMemberScope(klass)
 }
 
-fun nestedClassifierScope(klass: FirRegularClass): FirNestedClassifierScope {
+fun nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope {
     return klass
         .session
         .memberScopeProvider

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt

@@ -5,17 +5,18 @@
 
 package org.jetbrains.kotlin.fir.scopes.impl
 
+import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.name.Name
 
-class FirNestedClassifierScope(val klass: FirRegularClass) : FirScope() {
+class FirNestedClassifierScope(val klass: FirClass<*>) : FirScope() {
 
-    private val classIndex: Map<Name, FirClassSymbol> = run {
+    private val classIndex: Map<Name, FirRegularClassSymbol> = run {
-        val result = mutableMapOf<Name, FirClassSymbol>()
+        val result = mutableMapOf<Name, FirRegularClassSymbol>()
         for (declaration in klass.declarations) {
             if (declaration is FirRegularClass) {
                 result[declaration.name] = declaration.symbol

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt

@@ -192,11 +192,12 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
         //require(this is ConeSymbol)
         return when (this) {
             is FirTypeParameterSymbol,
+            is FirAnonymousObjectSymbol,
             is ConeCapturedTypeConstructor,
             is ErrorTypeConstructor,
             is ConeTypeVariableTypeConstructor,
             is ConeIntersectionType -> 0
-            is FirClassSymbol -> fir.typeParameters.size
+            is FirRegularClassSymbol -> fir.typeParameters.size
             is FirTypeAliasSymbol -> fir.typeParameters.size
             else -> error("?!:10")
         }
@@ -206,7 +207,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
         //require(this is ConeSymbol)
         return when (this) {
             is FirTypeParameterSymbol -> error("?!:11")
-            is FirClassSymbol -> fir.typeParameters[index].symbol
+            is FirRegularClassSymbol -> fir.typeParameters[index].symbol
             is FirTypeAliasSymbol -> fir.typeParameters[index].symbol
             else -> error("?!:12")
         }
@@ -218,7 +219,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
         return when (this) {
             is ConeTypeVariableTypeConstructor -> emptyList()
             is FirTypeParameterSymbol -> fir.bounds.map { it.coneTypeUnsafe() }
-            is FirClassSymbol -> fir.superConeTypes
+            is FirClassSymbol<*> -> fir.superConeTypes
             is FirTypeAliasSymbol -> listOfNotNull(fir.expandedConeType)
             is ConeCapturedTypeConstructor -> supertypes!!
             is ConeIntersectionType -> intersectedTypes
@@ -232,7 +233,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
 
     override fun TypeConstructorMarker.isClassTypeConstructor(): Boolean {
         //assert(this is ConeSymbol)
-        return this is FirClassSymbol
+        return this is FirClassSymbol<*>
     }
 
     override fun TypeParameterMarker.getVariance(): TypeVariance {
@@ -275,7 +276,8 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
     }
 
     override fun TypeConstructorMarker.isCommonFinalClassConstructor(): Boolean {
-        val classSymbol = this as? FirClassSymbol ?: return false
+        if (this is FirAnonymousObjectSymbol) return true
+        val classSymbol = this as? FirRegularClassSymbol ?: return false
         val fir = classSymbol.fir
         return fir.modality == Modality.FINAL &&
                 fir.classKind != ClassKind.ENUM_ENTRY &&
@@ -352,7 +354,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
         if (this is ConeIntersectionType) return false
         require(this is ConeLookupTagBasedType)
         val typeConstructor = this.typeConstructor()
-        return typeConstructor is FirClassSymbol ||
+        return typeConstructor is FirClassSymbol<*> ||
                 typeConstructor is FirTypeParameterSymbol
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/FirCorrespondingSupertypesCache.kt

@@ -7,6 +7,8 @@ package org.jetbrains.kotlin.fir.types
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
+import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
 import org.jetbrains.kotlin.fir.resolve.constructClassType
 import org.jetbrains.kotlin.fir.resolve.constructType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
@@ -52,15 +54,15 @@ class FirCorrespondingSupertypesCache(private val session: FirSession) : FirSess
     ): Map<FirClassLikeSymbol<*>, List<ConeClassLikeType>>? {
         val resultingMap = HashMap<FirClassLikeSymbol<*>, List<ConeClassLikeType>>()
 
-        val subtypeClassSymbol = with(context) {
+        val subtypeClassSymbol: FirClassLikeSymbol<*> = with(context) {
             subtype.typeConstructor() as? FirClassLikeSymbol<*> ?: return null
         }
-        val subtypeFirClass = subtypeClassSymbol.fir
+        val subtypeFirClass: FirClassLikeDeclaration<*> = subtypeClassSymbol.fir
 
         val defaultType = subtypeClassSymbol.toLookupTag().constructClassType(
-            subtypeFirClass.typeParameters.map {
+            (subtypeFirClass as? FirTypeParametersOwner)?.typeParameters?.map {
                 it.symbol.toLookupTag().constructType(emptyArray(), isNullable = false)
-            }.toTypedArray(),
+            }?.toTypedArray().orEmpty(),
             isNullable = false
         )
 

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

@@ -236,7 +236,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         visitDeclaration(namedDeclaration)
         if (namedDeclaration !is FirCallableDeclaration<*>) { // Handled by visitCallableDeclaration
             print(" " + namedDeclaration.name)
-            if (namedDeclaration is FirClassLikeDeclaration<*>) {
+            if (namedDeclaration is FirTypeParametersOwner) {
                 namedDeclaration.typeParameters.renderTypeParameters()
             }
         } else if (namedDeclaration is FirMemberDeclaration) {

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

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -19,15 +20,17 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirAnonymousObject : FirPureAbstractElement(), FirClass, FirExpression {
+abstract class FirAnonymousObject : FirPureAbstractElement(), FirClass<FirAnonymousObject>, FirExpression {
     abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
+    abstract override val supertypesComputationStatus: SupertypesComputationStatus
     abstract override val classKind: ClassKind
     abstract override val superTypeRefs: List<FirTypeRef>
     abstract override val declarations: List<FirDeclaration>
     abstract override val annotations: List<FirAnnotationCall>
     abstract override val typeRef: FirTypeRef
+    abstract override val symbol: FirAnonymousObjectSymbol
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnonymousObject(this, data)
 }

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

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -19,10 +20,12 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-interface FirClass : FirDeclaration, FirStatement, FirAnnotationContainer {
+interface FirClass<F : FirClass<F>> : FirClassLikeDeclaration<F>, FirStatement, FirAnnotationContainer {
     override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
+    override val supertypesComputationStatus: SupertypesComputationStatus
+    override val symbol: FirClassSymbol<F>
     val classKind: ClassKind
     val superTypeRefs: List<FirTypeRef>
     val declarations: List<FirDeclaration>

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

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -19,14 +18,11 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-interface FirClassLikeDeclaration<F : FirClassLikeDeclaration<F>> : FirStatement, FirMemberDeclaration, FirSymbolOwner<F>, FirTypeParametersOwner {
+interface FirClassLikeDeclaration<F : FirClassLikeDeclaration<F>> : FirDeclaration, FirStatement, FirSymbolOwner<F> {
     override val source: FirSourceElement?
-    override val annotations: List<FirAnnotationCall>
     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
     val supertypesComputationStatus: SupertypesComputationStatus
     override val symbol: FirClassLikeSymbol<F>
 

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

@@ -9,6 +9,9 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 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.symbols.impl.FirAnonymousObjectSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
 
@@ -60,7 +63,13 @@ val FirTypeAlias.expandedConeType: ConeClassLikeType? get() = expandedTypeRef.co
 
 val FirRegularClass.classId get() = symbol.classId
 
-val FirClass.superConeTypes get() = superTypeRefs.mapNotNull { it.coneTypeSafe<ConeClassLikeType>() }
+val FirClassSymbol<*>.superConeTypes
+    get() = when (this) {
+        is FirRegularClassSymbol -> fir.superConeTypes
+        is FirAnonymousObjectSymbol -> fir.superConeTypes
+    }
+
+val FirClass<*>.superConeTypes get() = superTypeRefs.mapNotNull { it.coneTypeSafe<ConeClassLikeType>() }
 
 fun FirRegularClass.collectEnumEntries(): Collection<FirEnumEntry> {
     assert(classKind == ClassKind.ENUM_CLASS)

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

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -32,7 +32,7 @@ abstract class FirEnumEntry : FirPureAbstractElement(), FirRegularClass {
     abstract override val supertypesComputationStatus: SupertypesComputationStatus
     abstract override val classKind: ClassKind
     abstract override val declarations: List<FirDeclaration>
-    abstract override val symbol: FirClassSymbol
+    abstract override val symbol: FirRegularClassSymbol
     abstract override val companionObject: FirRegularClass?
     abstract override val superTypeRefs: List<FirTypeRef>
     abstract val arguments: List<FirExpression>

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

@@ -9,7 +9,7 @@ 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.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-interface FirRegularClass : FirNamedDeclaration, FirClassLikeDeclaration<FirRegularClass>, FirClass {
+interface FirRegularClass : FirMemberDeclaration, FirTypeParametersOwner, FirClass<FirRegularClass> {
     override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
@@ -30,7 +30,7 @@ interface FirRegularClass : FirNamedDeclaration, FirClassLikeDeclaration<FirRegu
     override val supertypesComputationStatus: SupertypesComputationStatus
     override val classKind: ClassKind
     override val declarations: List<FirDeclaration>
-    override val symbol: FirClassSymbol
+    override val symbol: FirRegularClassSymbol
     val companionObject: FirRegularClass?
     override val superTypeRefs: List<FirTypeRef>
 

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

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+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
@@ -32,7 +32,7 @@ abstract class FirSealedClass : FirPureAbstractElement(), FirRegularClass {
     abstract override val supertypesComputationStatus: SupertypesComputationStatus
     abstract override val classKind: ClassKind
     abstract override val declarations: List<FirDeclaration>
-    abstract override val symbol: FirClassSymbol
+    abstract override val symbol: FirRegularClassSymbol
     abstract override val companionObject: FirRegularClass?
     abstract override val superTypeRefs: List<FirTypeRef>
     abstract val inheritors: List<ClassId>

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

@@ -19,14 +19,14 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirTypeAlias : FirPureAbstractElement(), FirClassLikeDeclaration<FirTypeAlias> {
+abstract class FirTypeAlias : FirPureAbstractElement(), FirClassLikeDeclaration<FirTypeAlias>, FirMemberDeclaration, FirTypeParametersOwner {
     abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
+    abstract override val supertypesComputationStatus: SupertypesComputationStatus
     abstract override val name: Name
     abstract override val typeParameters: List<FirTypeParameter>
     abstract override val status: FirDeclarationStatus
-    abstract override val supertypesComputationStatus: SupertypesComputationStatus
     abstract override val symbol: FirTypeAliasSymbol
     abstract val expandedTypeRef: FirTypeRef
     abstract override val annotations: List<FirAnnotationCall>

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

@@ -11,8 +11,10 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+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.FirAnonymousObjectSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.*
@@ -24,15 +26,21 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 class FirAnonymousObjectImpl(
     override val source: FirSourceElement?,
-    override val session: FirSession
+    override val session: FirSession,
-) : FirAnonymousObject(), FirModifiableClass, FirAbstractAnnotatedElement {
+    override val symbol: FirAnonymousObjectSymbol
+) : FirAnonymousObject(), FirModifiableClass<FirAnonymousObject>, FirAbstractAnnotatedElement {
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    override var supertypesComputationStatus: SupertypesComputationStatus = SupertypesComputationStatus.NOT_COMPUTED
     override val classKind: ClassKind get() = ClassKind.OBJECT
     override val superTypeRefs: MutableList<FirTypeRef> = mutableListOf()
     override val declarations: MutableList<FirDeclaration> = mutableListOf()
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
 
+    init {
+        symbol.bind(this)
+    }
+
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         superTypeRefs.forEach { it.accept(visitor, data) }
         declarations.forEach { it.accept(visitor, data) }
@@ -52,6 +60,10 @@ class FirAnonymousObjectImpl(
         resolvePhase = newResolvePhase
     }
 
+    override fun replaceSupertypesComputationStatus(newSupertypesComputationStatus: SupertypesComputationStatus) {
+        supertypesComputationStatus = newSupertypesComputationStatus
+    }
+
     override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>) {
         superTypeRefs.clear()
         superTypeRefs.addAll(newSuperTypeRefs)

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

@@ -17,7 +17,7 @@ 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.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -33,7 +33,7 @@ class FirClassImpl(
     override val name: Name,
     override var status: FirDeclarationStatus,
     override val classKind: ClassKind,
-    override val symbol: FirClassSymbol
+    override val symbol: FirRegularClassSymbol
 ) : FirPureAbstractElement(), FirRegularClass, FirModifiableRegularClass, FirAbstractAnnotatedElement {
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()

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

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.declarations.SupertypesComputationStatus
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -34,8 +34,8 @@ class FirEnumEntryImpl(
     override val source: FirSourceElement?,
     override val session: FirSession,
     override val name: Name,
-    override val symbol: FirClassSymbol
+    override val symbol: FirRegularClassSymbol
-) : FirEnumEntry(), FirModifiableClass, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement {
+) : FirEnumEntry(), FirModifiableClass<FirRegularClass>, FirModifiableTypeParametersOwner, 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/FirModifiableClass.kt

@@ -11,8 +11,10 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+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.fir.visitors.*
 
@@ -21,17 +23,21 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-interface FirModifiableClass : FirClass, FirAbstractAnnotatedElement {
+interface FirModifiableClass<F : FirClass<F>>  : FirClass<F>, FirAbstractAnnotatedElement {
     override val source: FirSourceElement?
     override val session: FirSession
     override var resolvePhase: FirResolvePhase
+    override var supertypesComputationStatus: SupertypesComputationStatus
+    override val symbol: FirClassSymbol<F>
     override val classKind: ClassKind
     override val superTypeRefs: MutableList<FirTypeRef>
     override val declarations: MutableList<FirDeclaration>
     override val annotations: MutableList<FirAnnotationCall>
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableClass
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableClass<F>
 
     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/FirModifiableRegularClass.kt

@@ -16,7 +16,7 @@ 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.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-interface FirModifiableRegularClass : FirRegularClass, FirModifiableClass, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement {
+interface FirModifiableRegularClass : FirRegularClass, FirModifiableClass<FirRegularClass>, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement {
     override val source: FirSourceElement?
     override val session: FirSession
     override var resolvePhase: FirResolvePhase
@@ -37,7 +37,7 @@ interface FirModifiableRegularClass : FirRegularClass, FirModifiableClass, FirMo
     override var supertypesComputationStatus: SupertypesComputationStatus
     override val classKind: ClassKind
     override val declarations: MutableList<FirDeclaration>
-    override val symbol: FirClassSymbol
+    override val symbol: FirRegularClassSymbol
     override var companionObject: FirRegularClass?
     override val superTypeRefs: MutableList<FirTypeRef>
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableRegularClass

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

@@ -17,7 +17,7 @@ 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.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -34,7 +34,7 @@ class FirSealedClassImpl(
     override val name: Name,
     override var status: FirDeclarationStatus,
     override val classKind: ClassKind,
-    override val symbol: FirClassSymbol
+    override val symbol: FirRegularClassSymbol
 ) : FirSealedClass(), FirModifiableRegularClass, FirAbstractAnnotatedElement {
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()

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

@@ -33,8 +33,8 @@ class FirTypeAliasImpl(
     override var expandedTypeRef: FirTypeRef
 ) : FirTypeAlias(), FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement {
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
-    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
     override var supertypesComputationStatus: SupertypesComputationStatus = SupertypesComputationStatus.NOT_COMPUTED
+    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
 
     init {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/ConeClassLookupTagWithFixedSymbol.kt

@@ -0,0 +1,15 @@
+/*
+ * 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.symbols.impl
+
+import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
+import org.jetbrains.kotlin.name.ClassId
+
+data class ConeClassLookupTagWithFixedSymbol(
+    override val classId: ClassId,
+    val symbol: FirClassSymbol<*>
+) : ConeClassLikeLookupTag() {
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt

@@ -6,12 +6,11 @@
 package org.jetbrains.kotlin.fir.symbols.impl
 
 import org.jetbrains.kotlin.fir.FirSymbolOwner
-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
+import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.ConeTypeAliasLookupTag
 import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
 
 sealed class FirClassLikeSymbol<D>(
     val classId: ClassId
@@ -24,10 +23,18 @@ sealed class FirClassLikeSymbol<D>(
     override fun hashCode(): Int = fir.hashCode()
 }
 
-class FirClassSymbol(classId: ClassId) : FirClassLikeSymbol<FirRegularClass>(classId) {
+sealed class FirClassSymbol<C : FirClass<C>>(classId: ClassId) : FirClassLikeSymbol<C>(classId) {
-    override fun toLookupTag(): ConeClassLikeLookupTag = ConeClassLikeLookupTagImpl(classId)
+    private val lookupTag =
+        if (classId.isLocal) ConeClassLookupTagWithFixedSymbol(classId, this)
+        else ConeClassLikeLookupTagImpl(classId)
+
+    override fun toLookupTag(): ConeClassLikeLookupTag = lookupTag
 }
 
+class FirRegularClassSymbol(classId: ClassId) : FirClassSymbol<FirRegularClass>(classId)
+
+class FirAnonymousObjectSymbol : FirClassSymbol<FirAnonymousObject>(ClassId(FqName.ROOT, FqName("anonymous"), true))
+
 class FirTypeAliasSymbol(classId: ClassId) : FirClassLikeSymbol<FirTypeAlias>(classId) {
     override fun toLookupTag(): TypeAliasLookupTagImpl = TypeAliasLookupTagImpl(classId)
 }

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

@@ -5,6 +5,7 @@
 
 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.*

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

@@ -33,8 +33,8 @@ import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 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.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
@@ -234,12 +234,12 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformElement(field, data)
     }
 
-    open fun transformClass(klass: FirClass, data: D): CompositeTransformResult<FirStatement> {
+    open fun <F : FirClassLikeDeclaration<F>> transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirStatement> {
-        return transformElement(klass, data)
+        return transformElement(classLikeDeclaration, data)
     }
 
-    open fun <F : FirClassLikeDeclaration<F>> transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
+    open fun <F : FirClass<F>> transformClass(klass: FirClass<F>, data: D): CompositeTransformResult<FirStatement> {
-        return transformElement(classLikeDeclaration, data)
+        return transformElement(klass, data)
     }
 
     open fun transformRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult<FirStatement> {
@@ -674,12 +674,12 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformField(field, data)
     }
 
-    final override fun visitClass(klass: FirClass, data: D): CompositeTransformResult<FirStatement> {
+    final override fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirStatement> {
-        return transformClass(klass, data)
+        return transformClassLikeDeclaration(classLikeDeclaration, data)
     }
 
-    final override fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
+    final override fun <F : FirClass<F>> visitClass(klass: FirClass<F>, data: D): CompositeTransformResult<FirStatement> {
-        return transformClassLikeDeclaration(classLikeDeclaration, data)
+        return transformClass(klass, data)
     }
 
     final override fun visitRegularClass(regularClass: FirRegularClass, data: D): CompositeTransformResult<FirStatement> {

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

@@ -33,8 +33,8 @@ import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 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.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
@@ -178,10 +178,10 @@ abstract class FirVisitor<out R, in D> {
 
     open fun visitField(field: FirField, data: D): R  = visitElement(field, data)
 
-    open fun visitClass(klass: FirClass, data: D): R  = visitElement(klass, data)
-
     open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): R  = visitElement(classLikeDeclaration, data)
 
+    open fun <F : FirClass<F>> visitClass(klass: FirClass<F>, data: D): R  = visitElement(klass, data)
+
     open fun visitRegularClass(regularClass: FirRegularClass, data: D): R  = visitElement(regularClass, data)
 
     open fun visitSealedClass(sealedClass: FirSealedClass, data: D): R  = visitElement(sealedClass, data)

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

@@ -33,8 +33,8 @@ import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 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.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirSealedClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
@@ -232,14 +232,14 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(field)
     }
 
-    open fun visitClass(klass: FirClass) {
-        visitElement(klass)
-    }
-
     open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>) {
         visitElement(classLikeDeclaration)
     }
 
+    open fun <F : FirClass<F>> visitClass(klass: FirClass<F>) {
+        visitElement(klass)
+    }
+
     open fun visitRegularClass(regularClass: FirRegularClass) {
         visitElement(regularClass)
     }
@@ -672,14 +672,14 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitField(field)
     }
 
-    final override fun visitClass(klass: FirClass, data: Nothing?) {
-        visitClass(klass)
-    }
-
     final override fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: Nothing?) {
         visitClassLikeDeclaration(classLikeDeclaration)
     }
 
+    final override fun <F : FirClass<F>> visitClass(klass: FirClass<F>, data: Nothing?) {
+        visitClass(klass)
+    }
+
     final override fun visitRegularClass(regularClass: FirRegularClass, data: Nothing?) {
         visitRegularClass(regularClass)
     }

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

@@ -40,11 +40,11 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val valueParameter = element("ValueParameter", Declaration, variable)
     val property = element("Property", Declaration, variable, controlFlowGraphOwner, typeParametersOwner, callableMemberDeclaration)
     val field = element("Field", Declaration, variable, callableMemberDeclaration) // TODO: add noImpl
-    val klass = element("Class", Declaration, declaration, statement, annotationContainer)
+    val classLikeDeclaration = element("ClassLikeDeclaration", Declaration, declaration, statement, symbolOwner)
-    val classLikeDeclaration = element("ClassLikeDeclaration", Declaration, statement, memberDeclaration, symbolOwner, typeParametersOwner)
+    val klass = element("Class", Declaration, classLikeDeclaration, statement, annotationContainer)
-    val regularClass = element("RegularClass", Declaration, namedDeclaration, classLikeDeclaration, klass)
+    val regularClass = element("RegularClass", Declaration, memberDeclaration, typeParametersOwner, klass)
     val sealedClass = element("SealedClass", Declaration, regularClass)
-    val typeAlias = element("TypeAlias", Declaration, classLikeDeclaration)
+    val typeAlias = element("TypeAlias", Declaration, classLikeDeclaration, memberDeclaration, typeParametersOwner)
     val enumEntry = element("EnumEntry", Declaration, regularClass)
 
     val function = element("Function", Declaration, callableDeclaration, controlFlowGraphOwner, targetElement, annotationContainer, typeParametersOwner, statement)

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

@@ -54,7 +54,7 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
         val modifiableClass = impl(klass, "FirModifiableClass")
 
         val modifiableRegularClass = impl(regularClass, "FirModifiableRegularClass") {
-            parents += modifiableClass
+            parents += modifiableClass.withArg(regularClass)
             parents += modifiableTypeParametersOwner
         }
 
@@ -68,15 +68,16 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
         impl(sealedClass, config = regularClassConfig)
 
         impl(anonymousObject) {
-            parents += modifiableClass
+            parents += modifiableClass.withArg(anonymousObject)
             default("classKind") {
                 value = "ClassKind.OBJECT"
                 withGetter = true
             }
+            defaultSupertypesComputationStatus()
         }
 
         impl(enumEntry) {
-            parents += modifiableClass
+            parents += modifiableClass.withArg(regularClass)
             parents += modifiableTypeParametersOwner
             default("status", "FirDeclarationStatusImpl(Visibilities.UNKNOWN, Modality.FINAL)")
             default("classKind") {

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

@@ -199,13 +199,6 @@ object NodeConfigurator : AbstractFieldConfigurator() {
             needTransformOtherChildren()
         }
 
-        klass.configure {
-            +classKind
-            +superTypeRefs(withReplace = true)
-            +declarations
-            +annotations
-        }
-
         classLikeDeclaration.configure {
             withArg("F", "FirClassLikeDeclaration<F>")
             parentArg(symbolOwner, "F", "F")
@@ -213,13 +206,28 @@ object NodeConfigurator : AbstractFieldConfigurator() {
             +symbol("FirClassLikeSymbol", "F")
         }
 
+        klass.configure {
+            withArg("F", "FirClass<F>")
+            parentArg(classLikeDeclaration, "F", "F")
+            +symbol("FirClassSymbol", "F")
+            +classKind
+            +superTypeRefs(withReplace = true)
+            +declarations
+            +annotations
+        }
+
         regularClass.configure {
-            parentArg(classLikeDeclaration, "F", regularClass)
+            parentArg(klass, "F", regularClass)
-            +symbol("FirClassSymbol")
+            +symbol("FirRegularClassSymbol")
             +field("companionObject", regularClass, nullable = true)
             +superTypeRefs(withReplace = true)
         }
 
+        anonymousObject.configure {
+            parentArg(klass, "F", anonymousObject)
+            +symbol("FirAnonymousObjectSymbol")
+        }
+
         sealedClass.configure {
             +fieldList("inheritors", classIdType, withReplace = true)
         }

compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt

@@ -431,7 +431,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() {
                 val fir = symbolProvider.getClassLikeSymbolByFqName(it)?.fir
                 if (fir is FirClass) {
                     data.append(fir.classKind.name.toLowerCase()).append(" ")
-                    data.append(fir.name)
+                    data.append((fir as? FirRegularClass)?.name ?: Name.special("<anonymous>"))
                     if (fir.superTypeRefs.any { it.render() != "kotlin/Any" }) {
                         data.append(": ")
                         fir.superTypeRefs.joinTo(data, separator = ", ") { typeRef -> typeRef.render() }