FIR: introduce class & type alias symbols

compiler/fir/cones/src/org/jetbrains/kotlin/fir/symbols/ConeSymbols.kt

@@ -5,12 +5,21 @@
 
 package org.jetbrains.kotlin.fir.symbols
 
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.name.ClassId
 
 interface ConeSymbol
 
 interface ConeTypeParameterSymbol : ConeSymbol
 
-class ConeClassLikeSymbol(val classId: ClassId) : ConeSymbol
+interface ConeClassLikeSymbol : ConeSymbol {
+    val classId: ClassId
+}
 
-fun ClassId.toSymbol() = ConeClassLikeSymbol(this)
+interface ConeTypeAliasSymbol : ConeClassLikeSymbol {
+    val expansionType: ConeClassLikeType
+}
+
+interface ConeClassSymbol : ConeClassLikeSymbol {
+    val superTypes: List<ConeClassLikeType>
+}

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

@@ -17,11 +17,15 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBody
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.impl.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.FirType
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.impl.*
 import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.hasActualModifier
@@ -212,8 +216,11 @@ class RawFirBuilder(val session: FirSession) {
             return firConstructor
         }
 
+        lateinit var packageFqName: FqName
+
         override fun visitKtFile(file: KtFile, data: Unit): FirElement {
-            val firFile = FirFileImpl(session, file, file.name, file.packageFqName)
+            packageFqName = file.packageFqName
+            val firFile = FirFileImpl(session, file, file.name, packageFqName)
             for (annotationEntry in file.annotationEntries) {
                 firFile.annotations += annotationEntry.convert<FirAnnotationCall>()
             }
@@ -233,63 +240,85 @@ class RawFirBuilder(val session: FirSession) {
         }
 
         override fun visitEnumEntry(enumEntry: KtEnumEntry, data: Unit): FirElement {
-            val firEnumEntry = FirEnumEntryImpl(
+            return withChildClassName(enumEntry.nameAsSafeName) {
-                session,
+                val firEnumEntry = FirEnumEntryImpl(
-                enumEntry,
+                    session,
-                enumEntry.nameAsSafeName
+                    enumEntry,
-            )
+                    FirClassSymbol(currentClassId),
-            enumEntry.extractAnnotationsTo(firEnumEntry)
+                    enumEntry.nameAsSafeName
-            enumEntry.extractSuperTypeListEntriesTo(firEnumEntry)
+                )
-            for (declaration in enumEntry.declarations) {
+                enumEntry.extractAnnotationsTo(firEnumEntry)
-                firEnumEntry.declarations += declaration.convert<FirDeclaration>()
+                enumEntry.extractSuperTypeListEntriesTo(firEnumEntry)
+                for (declaration in enumEntry.declarations) {
+                    firEnumEntry.declarations += declaration.convert<FirDeclaration>()
+                }
+                firEnumEntry
             }
-            return firEnumEntry
         }
 
+        inline fun <T> withChildClassName(name: Name, l: () -> T): T {
+            className = className.child(name)
+            val t = l()
+            className = className.parent()
+            return t
+        }
+
+        val currentClassId get() = ClassId(packageFqName, className, false)
+
+        var className: FqName = FqName.ROOT
+
         override fun visitClassOrObject(classOrObject: KtClassOrObject, data: Unit): FirElement {
-            val classKind = when (classOrObject) {
+            return withChildClassName(classOrObject.nameAsSafeName) {
-                is KtObjectDeclaration -> ClassKind.OBJECT
+
-                is KtClass -> when {
+                val classKind = when (classOrObject) {
-                    classOrObject.isInterface() -> ClassKind.INTERFACE
+                    is KtObjectDeclaration -> ClassKind.OBJECT
-                    classOrObject.isEnum() -> ClassKind.ENUM_CLASS
+                    is KtClass -> when {
-                    classOrObject.isAnnotation() -> ClassKind.ANNOTATION_CLASS
+                        classOrObject.isInterface() -> ClassKind.INTERFACE
-                    else -> ClassKind.CLASS
+                        classOrObject.isEnum() -> ClassKind.ENUM_CLASS
+                        classOrObject.isAnnotation() -> ClassKind.ANNOTATION_CLASS
+                        else -> ClassKind.CLASS
+                    }
+                    else -> throw AssertionError("Unexpected class or object: ${classOrObject.text}")
                 }
-                else -> throw AssertionError("Unexpected class or object: ${classOrObject.text}")
+                val firClass = FirClassImpl(
+                    session,
+                    classOrObject,
+                    FirClassSymbol(currentClassId),
+                    classOrObject.nameAsSafeName,
+                    classOrObject.visibility,
+                    classOrObject.modality,
+                    classOrObject.platformStatus,
+                    classKind,
+                    isInner = classOrObject.hasModifier(KtTokens.INNER_KEYWORD),
+                    isCompanion = (classOrObject as? KtObjectDeclaration)?.isCompanion() == true,
+                    isData = (classOrObject as? KtClass)?.isData() == true
+                )
+                classOrObject.extractAnnotationsTo(firClass)
+                classOrObject.extractTypeParametersTo(firClass)
+                classOrObject.extractSuperTypeListEntriesTo(firClass)
+                for (declaration in classOrObject.declarations) {
+                    firClass.declarations += declaration.convert<FirDeclaration>()
+                }
+
+                firClass
             }
-            val firClass = FirClassImpl(
-                session,
-                classOrObject,
-                classOrObject.nameAsSafeName,
-                classOrObject.visibility,
-                classOrObject.modality,
-                classOrObject.platformStatus,
-                classKind,
-                isInner = classOrObject.hasModifier(KtTokens.INNER_KEYWORD),
-                isCompanion = (classOrObject as? KtObjectDeclaration)?.isCompanion() == true,
-                isData = (classOrObject as? KtClass)?.isData() == true
-            )
-            classOrObject.extractAnnotationsTo(firClass)
-            classOrObject.extractTypeParametersTo(firClass)
-            classOrObject.extractSuperTypeListEntriesTo(firClass)
-            for (declaration in classOrObject.declarations) {
-                firClass.declarations += declaration.convert<FirDeclaration>()
-            }
-            return firClass
         }
 
         override fun visitTypeAlias(typeAlias: KtTypeAlias, data: Unit): FirElement {
-            val firTypeAlias = FirTypeAliasImpl(
+            return withChildClassName(typeAlias.nameAsSafeName) {
-                session,
+                val firTypeAlias = FirTypeAliasImpl(
-                typeAlias,
+                    session,
-                typeAlias.nameAsSafeName,
+                    typeAlias,
-                typeAlias.visibility,
+                    FirTypeAliasSymbol(currentClassId),
-                typeAlias.platformStatus,
+                    typeAlias.nameAsSafeName,
-                typeAlias.getTypeReference().toFirOrErrorType()
+                    typeAlias.visibility,
-            )
+                    typeAlias.platformStatus,
-            typeAlias.extractAnnotationsTo(firTypeAlias)
+                    typeAlias.getTypeReference().toFirOrErrorType()
-            typeAlias.extractTypeParametersTo(firTypeAlias)
+                )
-            return firTypeAlias
+                typeAlias.extractAnnotationsTo(firTypeAlias)
+                typeAlias.extractTypeParametersTo(firTypeAlias)
+                firTypeAlias
+            }
         }
 
         override fun visitNamedFunction(function: KtNamedFunction, data: Unit): FirElement {
@@ -449,10 +478,10 @@ class RawFirBuilder(val session: FirSession) {
             val firTypeParameter = FirTypeParameterImpl(
                 session,
                 parameter,
+                FirTypeParameterSymbol(),
                 parameter.nameAsSafeName,
                 parameter.variance,
-                parameter.hasModifier(KtTokens.REIFIED_KEYWORD),
+                parameter.hasModifier(KtTokens.REIFIED_KEYWORD)
-                FirTypeParameterSymbol()
             )
             parameter.extractAnnotationsTo(firTypeParameter)
             val extendsBound = parameter.extendsBound

compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirClassifierResolveTransformer.kt

@@ -14,8 +14,6 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedTypeAliasImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedTypeParameterImpl
 import org.jetbrains.kotlin.fir.descriptors.ConeClassifierDescriptor
 import org.jetbrains.kotlin.fir.descriptors.ConeTypeParameterDescriptor
-import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
-import org.jetbrains.kotlin.fir.symbols.toSymbol
 import org.jetbrains.kotlin.fir.types.FirResolvedType
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.FirTransformer

compiler/fir/resolve/src/org/jetbrains/kotlin/descriptors/FirTypeResolveTransformer.kt

@@ -42,7 +42,7 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf
                 // from high priority to low priority
                 FirExplicitImportingScope(file.imports),
                 FirSelfImportingScope(file.packageFqName, file.session),
-                FirStarImportingScope(file.imports)
+                FirStarImportingScope(file.imports, file.session)
             )
         )
         packageFqName = file.packageFqName

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

@@ -15,7 +15,9 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 
 interface FirProvider {
-    fun getFirClassifierByFqName(fqName: ClassId): FirMemberDeclaration? // FirSymbol?
+    fun getFirClassifierByFqName(fqName: ClassId): FirMemberDeclaration?
+
+    fun getSymbolByFqName(fqName: ClassId): ConeSymbol?
 
     fun getFirClassifierContainerFile(fqName: ClassId): FirFile
 

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeSymbol
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -25,6 +26,10 @@ class FirProviderImpl(val session: FirSession) : FirProvider {
         }
     }
 
+    override fun getSymbolByFqName(fqName: ClassId): ConeSymbol? {
+        return (getFirClassifierByFqName(fqName) as? FirSymbolOwner<*>)?.symbol
+    }
+
     override fun getFirClassifierContainerFile(fqName: ClassId): FirFile {
         return classifierContainerFileMap[fqName] ?: error("Couldn't find container for $fqName")
     }

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

@@ -6,19 +6,13 @@
 package org.jetbrains.kotlin.fir.resolve.impl
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeSymbol
-import org.jetbrains.kotlin.fir.symbols.toSymbol
+import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.FirQualifierPart
-import org.jetbrains.kotlin.fir.types.impl.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.types.Variance
 
 class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver {
 
@@ -30,9 +24,9 @@ class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver {
             parts.drop(1).fold(prefix.relativeClassName) { prefix, suffix -> prefix.child(suffix.name) },
             false
         )
-        firProvider.getFirClassifierByFqName(fqName) ?: return null
+        val classifier = firProvider.getFirClassifierByFqName(fqName) ?: return null
 
-        return ConeClassLikeSymbol(fqName)
+        return (classifier as? FirSymbolOwner<*>)?.symbol
     }
 
     override fun resolveSymbol(parts: List<FirQualifierPart>): ConeSymbol? {
@@ -48,15 +42,12 @@ class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver {
 
                 val fqName = ClassId(firstPart.toFqName(), lastPart.toFqName(), false)
                 val foundClassifier = firProvider.getFirClassifierByFqName(fqName)
-
                 if (foundClassifier != null) {
-                    return ConeClassLikeSymbol(fqName)
+                    return (foundClassifier as? FirSymbolOwner<*>)?.symbol
                 }
             }
-            return null
-        } else {
-            return null
         }
+        return null
     }
 
     private fun List<FirQualifierPart>.toFqNameUnsafe() = toFqName().toUnsafe()

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

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.declarations.FirImport
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
+import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.symbols.ConeSymbol
-import org.jetbrains.kotlin.fir.symbols.toSymbol
 import org.jetbrains.kotlin.name.Name
 
 class FirExplicitImportingScope(imports: List<FirImport>) : FirScope {
@@ -26,8 +26,11 @@ class FirExplicitImportingScope(imports: List<FirImport>) : FirScope {
         processor: (ConeSymbol) -> Boolean
     ): Boolean {
         val imports = simpleImports[name] ?: return true
+        if (imports.isEmpty()) return true
+        val provider = FirProvider.getInstance(imports.first().session)
         for (import in imports) {
-            if (!processor(import.resolvedFqName.toSymbol())) {
+            val symbol = provider.getSymbolByFqName(import.resolvedFqName) ?: continue
+            if (!processor(symbol)) {
                 return false
             }
         }

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

@@ -6,12 +6,10 @@
 package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.symbols.ConeSymbol
-import org.jetbrains.kotlin.fir.symbols.toSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -19,16 +17,15 @@ class FirNestedClassifierScope(val classId: ClassId, val session: FirSession) :
 
     private val firProvider = FirProvider.getInstance(session)
 
-    private fun ClassId.getFir(): FirMemberDeclaration? {
-        return firProvider.getFirClassifierByFqName(this)
-    }
 
     override fun processClassifiersByName(
         name: Name,
         position: FirPosition,
         processor: (ConeSymbol) -> Boolean
     ): Boolean {
-        val child = ClassId(classId.packageFqName, classId.relativeClassName.child(name), false)
+        val child = classId.createNestedClassId(name)
-        return child.getFir() == null || processor(child.toSymbol())
+        val symbol = firProvider.getSymbolByFqName(child)
+
+        return symbol == null || processor(symbol)
     }
 }

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

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.ConeSymbol
-import org.jetbrains.kotlin.fir.symbols.toSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -26,8 +25,9 @@ class FirSelfImportingScope(val fqName: FqName, val session: FirSession) : FirSc
 
         val firProvider = session.service<FirProvider>()
 
-        return if (firProvider.getFirClassifierByFqName(unambiguousFqName) != null) {
+        val symbol = firProvider.getSymbolByFqName(unambiguousFqName)
-            processor(unambiguousFqName.toSymbol())
+        return if (symbol != null) {
+            processor(symbol)
         } else {
             true
         }

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

@@ -5,16 +5,18 @@
 
 package org.jetbrains.kotlin.fir.scopes.impl
 
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirImport
 import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
+import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.symbols.ConeSymbol
-import org.jetbrains.kotlin.fir.symbols.toSymbol
+import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
-class FirStarImportingScope(imports: List<FirImport>) : FirScope {
+class FirStarImportingScope(imports: List<FirImport>, val session: FirSession) : FirScope {
 
     private val starImports = imports.filterIsInstance<FirResolvedImport>().filter { it.isAllUnder }
 
@@ -23,13 +25,15 @@ class FirStarImportingScope(imports: List<FirImport>) : FirScope {
         position: FirPosition,
         processor: (ConeSymbol) -> Boolean
     ): Boolean {
+        val provider = FirProvider.getInstance(session)
         for (import in starImports) {
             val relativeClassName = import.relativeClassName
-            val symbol = if (relativeClassName == null) {
+            val classId = if (relativeClassName == null) {
                 ClassId(import.packageFqName, name)
             } else {
                 ClassId(import.packageFqName, relativeClassName.child(name), false)
-            }.toSymbol()
+            }
+            val symbol = provider.getSymbolByFqName(classId) ?: continue
             if (!processor(symbol)) {
                 return false
             }

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

@@ -7,13 +7,14 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.BaseTransformedType
+import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
 import org.jetbrains.kotlin.fir.types.FirType
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 // May be all containers should be properties and not base classes
 // About descriptors: introduce something like FirDescriptor which is FirUnresolved at the beginning and FirSymbol(descriptor) at the end
 @BaseTransformedType
-interface FirClass : FirDeclarationContainer, FirMemberDeclaration {
+interface FirClass : FirDeclarationContainer, FirMemberDeclaration, FirSymbolOwner<FirClass> {
     // including delegated types
     val superTypes: List<FirType>
 

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

@@ -5,10 +5,11 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
+import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
 import org.jetbrains.kotlin.fir.types.FirType
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirTypeAlias : FirMemberDeclaration {
+interface FirTypeAlias : FirMemberDeclaration, FirSymbolOwner<FirTypeAlias> {
     val expandedType: FirType
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =

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

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirMemberPlatformStatus
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.types.FirType
 import org.jetbrains.kotlin.name.Name
@@ -21,6 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 open class FirClassImpl(
     session: FirSession,
     psi: PsiElement?,
+    final override val symbol: FirBasedSymbol<FirClass>,
     name: Name,
     visibility: Visibility,
     modality: Modality?,
@@ -30,6 +32,11 @@ open class FirClassImpl(
     final override val isCompanion: Boolean,
     final override val isData: Boolean
 ) : FirAbstractMemberDeclaration(session, psi, name, visibility, modality, platformStatus), FirClass {
+
+    init {
+        symbol.bind(this)
+    }
+
     override val superTypes = mutableListOf<FirType>()
 
     override val declarations = mutableListOf<FirDeclaration>()

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

@@ -13,15 +13,18 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
 import org.jetbrains.kotlin.fir.declarations.FirMemberPlatformStatus
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.name.Name
 
 class FirEnumEntryImpl(
     session: FirSession,
     psi: PsiElement?,
+    symbol: FirClassSymbol,
     name: Name
 ) : FirClassImpl(
     session,
     psi,
+    symbol,
     name,
     visibility = Visibilities.UNKNOWN,
     modality = Modality.FINAL,

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

@@ -17,6 +17,7 @@ class FirResolvedClassImpl(val delegate: FirClass, override val descriptor: FirB
     FirResolvedClass, FirClass by delegate {
 
     init {
+        symbol.bind(this)
         descriptor.bind(this)
     }
 

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

@@ -17,6 +17,7 @@ class FirResolvedEnumEntryImpl(
 ) : FirResolvedEnumEntry, FirEnumEntry by delegate {
 
     init {
+        symbol.bind(this)
         descriptor.bind(this)
     }
 

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

@@ -19,6 +19,7 @@ class FirResolvedTypeAliasImpl(val delegate: FirTypeAlias, override val descript
         get() = delegate.modality ?: Modality.FINAL
 
     init {
+        symbol.bind(this)
         descriptor.bind(this)
     }
 

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirMemberPlatformStatus
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirType
@@ -21,11 +22,17 @@ import org.jetbrains.kotlin.name.Name
 class FirTypeAliasImpl(
     session: FirSession,
     psi: PsiElement?,
+    override val symbol: FirTypeAliasSymbol,
     name: Name,
     visibility: Visibility,
     platformStatus: FirMemberPlatformStatus,
     override var expandedType: FirType
 ) : FirAbstractMemberDeclaration(session, psi, name, visibility, Modality.FINAL, platformStatus), FirTypeAlias {
+
+    init {
+        symbol.bind(this)
+    }
+
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         typeParameters.transformInplace(transformer, data)
         expandedType = expandedType.transformSingle(transformer, data)

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

@@ -19,10 +19,10 @@ import org.jetbrains.kotlin.types.Variance
 class FirTypeParameterImpl(
     session: FirSession,
     psi: PsiElement?,
+    override val symbol: FirTypeParameterSymbol,
     name: Name,
     override val variance: Variance,
-    override val isReified: Boolean,
+    override val isReified: Boolean
-    override val symbol: FirTypeParameterSymbol
 ) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirTypeParameter {
     init {
         symbol.bind(this)

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

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. 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.declarations.FirClass
+import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.ConeClassSymbol
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.coneTypeUnsafe
+import org.jetbrains.kotlin.name.ClassId
+
+class FirClassSymbol(override val classId: ClassId) : ConeClassSymbol, AbstractFirBasedSymbol<FirClass>() {
+    override val superTypes: List<ConeClassLikeType>
+        get() = fir.superTypes.map { it.coneTypeUnsafe<ConeClassLikeType>() }
+}

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

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. 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.declarations.FirTypeAlias
+import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.ConeTypeAliasSymbol
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.coneTypeUnsafe
+import org.jetbrains.kotlin.name.ClassId
+
+class FirTypeAliasSymbol(override val classId: ClassId) : ConeTypeAliasSymbol, AbstractFirBasedSymbol<FirTypeAlias>() {
+    override val expansionType: ConeClassLikeType
+        get() = fir.expandedType.coneTypeUnsafe()
+
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirBuiltinType.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.types.impl
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.symbols.toSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirResolvedType
 import org.jetbrains.kotlin.name.ClassId
@@ -21,10 +21,12 @@ sealed class FirBuiltinType(
     val name: String
 ) : FirResolvedType {
     final override val type: ConeKotlinType = ConeClassTypeImpl(
-        ClassId(
+        FirClassSymbol(
-            KOTLIN_PACKAGE_FQ_NAME,
+            ClassId(
-            Name.identifier(name)
+                KOTLIN_PACKAGE_FQ_NAME,
-        ).toSymbol(),
+                Name.identifier(name)
+            )
+        ),
         emptyList()
     )