Implement FIR loading for libraries (classes, supertypes, parameters)

Members aren't implemented yet
Related to KT-28788, KT-28918

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

@@ -5,8 +5,6 @@
 
 package org.jetbrains.kotlin.fir.symbols
 
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -18,16 +16,8 @@ interface ConeTypeParameterSymbol : ConeSymbol {
 
 interface ConeClassLikeSymbol : ConeSymbol {
     val classId: ClassId
-
-    val typeParameters: List<ConeTypeParameterSymbol>
 }
 
-interface ConeTypeAliasSymbol : ConeClassLikeSymbol {
-    val expansionType: ConeClassLikeType?
-}
+interface ConeTypeAliasSymbol : ConeClassLikeSymbol
 
-interface ConeClassSymbol : ConeClassLikeSymbol {
-    val kind: ClassKind
-
-    val superTypes: List<ConeClassLikeType>
-}
+interface ConeClassSymbol : ConeClassLikeSymbol

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/symbols/JavaClassSymbol.kt

@@ -5,30 +5,13 @@
 
 package org.jetbrains.kotlin.fir.java.symbols
 
-import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.symbols.ConeClassSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
-import org.jetbrains.kotlin.fir.types.ConeClassErrorType
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.classId
 import org.jetbrains.kotlin.name.ClassId
 
 class JavaClassSymbol(javaClass: JavaClass) : ConeClassSymbol {
     override val classId: ClassId = javaClass.classId ?: error("!")
-
-    override val typeParameters: List<ConeTypeParameterSymbol> =
-        javaClass.typeParameters.map { JavaTypeParameterSymbol(it.name) }
-
-    override val kind: ClassKind = when {
-        javaClass.isEnum -> ClassKind.ENUM_CLASS
-        javaClass.isInterface -> ClassKind.INTERFACE
-        javaClass.isAnnotationType -> ClassKind.ANNOTATION_CLASS
-        else -> ClassKind.CLASS
-    }
-
-    override val superTypes: List<ConeClassLikeType> =
-        listOf(ConeClassErrorType("Not supported: Java class supertypes"))
 }
 
 

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

@@ -10,6 +10,8 @@ import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
 import org.jetbrains.kotlin.fir.symbols.LibraryTypeParameterSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeAbbreviatedTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
@@ -19,6 +21,7 @@ import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
 import org.jetbrains.kotlin.serialization.deserialization.getClassId
 import org.jetbrains.kotlin.serialization.deserialization.getName
 import org.jetbrains.kotlin.types.Variance
+import java.lang.RuntimeException
 import java.util.*
 
 class FirTypeDeserializer(
@@ -30,8 +33,12 @@ class FirTypeDeserializer(
 ) {
 
     private fun computeClassifier(fqNameIndex: Int): ConeSymbol? {
-        val id = nameResolver.getClassId(fqNameIndex)
-        return symbolProvider.getClassLikeSymbolByFqName(id)
+        try {
+            val id = nameResolver.getClassId(fqNameIndex)
+            return symbolProvider.getClassLikeSymbolByFqName(id)
+        } catch (e: Throwable) {
+            throw RuntimeException("Looking up for ${nameResolver.getClassId(fqNameIndex)}", e)
+        }
     }
 
     fun type(proto: ProtoBuf.Type): ConeKotlinType {
@@ -64,6 +71,14 @@ class FirTypeDeserializer(
         get() = typeParameterDescriptors.values.toList()
 
 
+    fun ConeClassLikeSymbol.typeParameters(): List<ConeTypeParameterSymbol> = when (this) {
+        is FirTypeAliasSymbol -> fir.typeParameters
+        is FirClassSymbol -> fir.typeParameters
+        else -> error("?!id:2")
+    }.map {
+        it.symbol
+    }
+
     fun classLikeType(proto: ProtoBuf.Type): ConeClassLikeType? {
 
         val constructor = typeSymbol(proto) as? ConeClassLikeSymbol ?: return null
@@ -75,7 +90,7 @@ class FirTypeDeserializer(
             argumentList + outerType(typeTable)?.collectAllArguments().orEmpty()
 
         val arguments = proto.collectAllArguments().mapIndexed { index, proto ->
-            typeArgument(constructor.typeParameters.getOrNull(index), proto)
+            typeArgument(constructor.typeParameters().getOrNull(index), proto)
         }.toTypedArray()
 
         val simpleType = if (Flags.SUSPEND_TYPE.get(proto.flags)) {

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

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2010-2019 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.resolve
+
+inline fun <K, V, VA : V> MutableMap<K, V>.getOrPut(key: K, defaultValue: (K) -> VA, postCompute: (VA) -> Unit): V {
+    val value = get(key)
+    return if (value == null) {
+        val answer = defaultValue(key)
+        put(key, answer)
+        postCompute(answer)
+        answer
+    } else {
+        value
+    }
+}

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

@@ -9,20 +9,31 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
 import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
 import org.jetbrains.kotlin.fir.deserialization.FirTypeDeserializer
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.getOrPut
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.ConeSymbol
-import org.jetbrains.kotlin.fir.symbols.LibraryClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FictitiousFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
+import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeImpl
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
+import org.jetbrains.kotlin.metadata.deserialization.Flags
 import org.jetbrains.kotlin.metadata.deserialization.NameResolverImpl
 import org.jetbrains.kotlin.metadata.deserialization.TypeTable
+import org.jetbrains.kotlin.metadata.deserialization.supertypes
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.deserialization.ProtoBasedClassDataFinder
+import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
 import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerializerProtocol
+import org.jetbrains.kotlin.serialization.deserialization.getName
+import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 import java.io.InputStream
 
@@ -32,7 +43,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider
         return emptyList()
     }
 
-    private class BuiltInsPackageFragment(stream: InputStream, val fqName: FqName) {
+    private class BuiltInsPackageFragment(stream: InputStream, val fqName: FqName, val session: FirSession) {
         lateinit var version: BuiltInsBinaryVersion
 
         val packageProto: ProtoBuf.PackageFragment = run {
@@ -58,21 +69,56 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider
 
         val lookup = mutableMapOf<ClassId, ConeSymbol>()
 
+        private fun createTypeParameterSymbol(name: Name): FirTypeParameterSymbol {
+            val firSymbol = FirTypeParameterSymbol()
+            FirTypeParameterImpl(session, null, firSymbol, name, variance = Variance.INVARIANT, isReified = false)
+            return firSymbol
+        }
+
         fun getSymbolByFqName(classId: ClassId, provider: FirSymbolProvider): ConeSymbol? {
 
             if (classId !in classDataFinder.allClassIds) return null
-            return lookup.getOrPut(classId) {
+            return lookup.getOrPut(classId, { FirClassSymbol(classId) }) { symbol ->
                 val classData = classDataFinder.findClassData(classId)!!
-                LibraryClassSymbol(
-                    classData.classProto, classData.nameResolver,
-                    FirTypeDeserializer(
+                val classProto = classData.classProto
+                val flags = classProto.flags
+                val kind = Flags.CLASS_KIND.get(flags)
+                FirClassImpl(
+                    session, null, symbol, classId.shortClassName,
+                    ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+                    ProtoEnumFlags.modality(Flags.MODALITY.get(flags)),
+                    Flags.IS_EXPECT_CLASS.get(flags), false,
+                    ProtoEnumFlags.classKind(kind),
+                    Flags.IS_INNER.get(flags),
+                    kind == ProtoBuf.Class.Kind.COMPANION_OBJECT,
+                    Flags.IS_DATA.get(classProto.flags),
+                    Flags.IS_INLINE_CLASS.get(classProto.flags)
+                ).apply {
+                    for (typeParameter in classProto.typeParameterList) {
+                        typeParameters += createTypeParameterSymbol(classData.nameResolver.getName(typeParameter.name)).fir
+                    }
+                    //addAnnotationsFrom(classProto) ? TODO
+
+                    val typeTable = TypeTable(classData.classProto.typeTable)
+                    val typeDeserializer = FirTypeDeserializer(
                         classData.nameResolver,
-                        TypeTable(classData.classProto.typeTable),
+                        typeTable,
                         provider,
                         classData.classProto.typeParameterList,
                         null
                     )
-                )
+
+
+                    val superTypesDeserialized = classProto.supertypes(typeTable).map { supertypeProto ->
+                        typeDeserializer.classLikeType(supertypeProto)
+                    }// TODO: + c.components.additionalClassPartsProvider.getSupertypes(this@DeserializedClassDescriptor)
+
+                    superTypesDeserialized.mapNotNullTo(superTypes) {
+                        if (it == null) return@mapNotNullTo null
+                        FirResolvedTypeImpl(session, null, it, false, emptyList())
+                    }
+                    // TODO: declarations (probably should be done later)
+                }
             }
         }
     }
@@ -90,7 +136,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider
         return packageFqNames.map { fqName ->
             val resourcePath = BuiltInSerializerProtocol.getBuiltInsFilePath(fqName)
             val inputStream = streamProvider(resourcePath) ?: throw IllegalStateException("Resource not found in classpath: $resourcePath")
-            BuiltInsPackageFragment(inputStream, fqName)
+            BuiltInsPackageFragment(inputStream, fqName, session)
         }
     }
 

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

@@ -5,13 +5,14 @@
 
 package org.jetbrains.kotlin.fir.resolve.impl
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.expandedConeType
 import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver
 import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
 import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.*
 import org.jetbrains.kotlin.name.Name
@@ -46,11 +47,11 @@ class FirTypeResolverImpl : FirTypeResolver {
             is ConeClassSymbol -> {
                 ConeClassTypeImpl(this, parts.toTypeProjections())
             }
-            is ConeTypeAliasSymbol -> {
+            is FirTypeAliasSymbol -> {
                 ConeAbbreviatedTypeImpl(
                     abbreviationSymbol = this as ConeClassLikeSymbol,
                     typeArguments = parts.toTypeProjections(),
-                    directExpansion = expansionType ?: ConeClassErrorType("Unresolved expansion")
+                    directExpansion = fir.expandedConeType ?: ConeClassErrorType("Unresolved expansion")
                 )
             }
             else -> error("!")

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

@@ -7,10 +7,12 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.expandedConeType
+import org.jetbrains.kotlin.fir.declarations.superConeTypes
 import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeClassSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeTypeAliasSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.ConeAbbreviatedType
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
@@ -49,18 +51,18 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority: B
 
     private tailrec fun ConeClassLikeSymbol.collectSuperClasses(list: MutableList<ConeClassLikeType>) {
         when (this) {
-            is ConeClassSymbol -> {
+            is FirClassSymbol -> {
                 val superClassType =
-                    this.superTypes
+                    fir.superConeTypes
                         .map { it.computePartialExpansion() }
                         .firstOrNull {
-                            it !is ConeClassErrorType && (it?.symbol as? ConeClassSymbol)?.kind == ClassKind.CLASS
+                            it !is ConeClassErrorType && (it?.symbol as? FirClassSymbol)?.fir?.classKind == ClassKind.CLASS
                         } ?: return
                 list += superClassType
                 superClassType.symbol.collectSuperClasses(list)
             }
-            is ConeTypeAliasSymbol -> {
-                val expansion = expansionType?.computePartialExpansion() ?: return
+            is FirTypeAliasSymbol -> {
+                val expansion = fir.expandedConeType?.computePartialExpansion() ?: return
                 expansion.symbol.collectSuperClasses(list)
             }
             else -> error("?!id:1")
@@ -69,9 +71,9 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority: B
 
     private fun ConeClassLikeSymbol.collectSuperTypes(list: MutableList<ConeClassLikeType>, deep: Boolean) {
         when (this) {
-            is ConeClassSymbol -> {
+            is FirClassSymbol -> {
                 val superClassTypes =
-                    this.superTypes.mapNotNull { it.computePartialExpansion() }
+                    fir.superConeTypes.mapNotNull { it.computePartialExpansion() }
                 list += superClassTypes
                 if (deep)
                     superClassTypes.forEach {
@@ -80,8 +82,8 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority: B
                         }
                     }
             }
-            is ConeTypeAliasSymbol -> {
-                val expansion = expansionType?.computePartialExpansion() ?: return
+            is FirTypeAliasSymbol -> {
+                val expansion = fir.expandedConeType?.computePartialExpansion() ?: return
                 expansion.symbol.collectSuperTypes(list, deep)
             }
             else -> error("?!id:1")

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

@@ -15,6 +15,8 @@ import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
 import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.impl.*
 import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeImpl
@@ -180,11 +182,17 @@ open class FirTypeResolveTransformer(
             if (symbol is ConeClassLikeSymbol) {
                 if (symbol is FirBasedSymbol<*>) {
                     val classId = symbol.classId
+
+                    if (symbol is ConeTypeAliasSymbol) {
+                        val fir = symbol.fir as FirTypeAlias
+                        if (fir.expandedType is FirResolvedType) return
+                    } else if (symbol is ConeClassSymbol) {
+                        val fir = symbol.fir as FirClass
+                        if (fir.superTypes.all { it is FirResolvedType }) return
+                    }
                     val firProvider = FirProvider.getInstance(symbol.fir.session)
-
                     val classes = generateSequence(classId) { it.outerClassId }.toList().asReversed()
 
-
                     val file = firProvider.getFirClassifierContainerFile(classes.first())
 
                     val firElementsToVisit = classes.asSequence().map {
@@ -197,10 +205,10 @@ open class FirTypeResolveTransformer(
                     file.transformSingle(transformer, null)
 
                 } else {
-                    if (symbol is ConeTypeAliasSymbol) {
-                        symbol.expansionType?.let { if (it !is ConeClassErrorType) walkSymbols(it.symbol) }
-                    } else if (symbol is ConeClassSymbol) {
-                        symbol.superTypes.forEach { if (it !is ConeClassErrorType) walkSymbols(it.symbol) }
+                    if (symbol is FirTypeAliasSymbol) {
+                        symbol.fir.expandedConeType?.let { if (it !is ConeClassErrorType) walkSymbols(it.symbol) }
+                    } else if (symbol is FirClassSymbol) {
+                        symbol.fir.superConeTypes.forEach { if (it !is ConeClassErrorType) walkSymbols(it.symbol) }
                     }
                 }
             }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/symbols/LibraryClassSymbol.kt

@@ -1,41 +0,0 @@
-/*
- * 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
-
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.deserialization.FirTypeDeserializer
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.metadata.ProtoBuf
-import org.jetbrains.kotlin.metadata.deserialization.Flags
-import org.jetbrains.kotlin.metadata.deserialization.NameResolver
-import org.jetbrains.kotlin.metadata.deserialization.TypeTable
-import org.jetbrains.kotlin.metadata.deserialization.supertypes
-import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
-import org.jetbrains.kotlin.serialization.deserialization.getClassId
-
-class LibraryClassSymbol(
-    val classProto: ProtoBuf.Class,
-    nameResolver: NameResolver,
-    val typeDeserializer: FirTypeDeserializer
-) : ConeClassSymbol {
-
-    override val kind: ClassKind = ProtoEnumFlags.classKind(Flags.CLASS_KIND[classProto.flags])
-
-    override val typeParameters: List<ConeTypeParameterSymbol> by lazy { typeDeserializer.ownTypeParameters }
-    override val classId: ClassId = nameResolver.getClassId(classProto.fqName)
-
-    val typeTable = TypeTable(classProto.typeTable)
-
-    override val superTypes: List<ConeClassLikeType>
-        get() {
-            val result = classProto.supertypes(typeTable).map { supertypeProto ->
-                typeDeserializer.classLikeType(supertypeProto)
-            }// TODO: + c.components.additionalClassPartsProvider.getSupertypes(this@DeserializedClassDescriptor)
-
-            return result.filterNotNull()
-        }
-}

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

@@ -8,7 +8,9 @@ package org.jetbrains.kotlin.fir.declarations
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.expressions.FirStatement
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirClass : FirDeclarationContainer, FirStatement, FirAnnotationContainer {
@@ -28,4 +30,6 @@ interface FirClass : FirDeclarationContainer, FirStatement, FirAnnotationContain
             declaration.accept(visitor, data)
         }
     }
-}
+}
+
+val FirClass.superConeTypes get() = superTypes.mapNotNull { it.coneTypeSafe<ConeClassLikeType>() }

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

@@ -6,7 +6,9 @@
 package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirTypeAlias : FirMemberDeclaration, FirSymbolOwner<FirTypeAlias> {
@@ -19,4 +21,7 @@ interface FirTypeAlias : FirMemberDeclaration, FirSymbolOwner<FirTypeAlias> {
         super.acceptChildren(visitor, data)
         expandedType.accept(visitor, data)
     }
-}
+}
+
+
+val FirTypeAlias.expandedConeType: ConeClassLikeType? get() = expandedType.coneTypeSafe()

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

@@ -6,27 +6,16 @@
 package org.jetbrains.kotlin.fir.symbols.impl
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.symbols.ConeClassSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
 class FictitiousFunctionSymbol(className: Name, arity: Int) : ConeClassSymbol {
     override val classId = ClassId(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME, className)
 
-    override val typeParameters: List<ConeTypeParameterSymbol> = (0..arity).map {
-        TypeParameterSymbol(it)
-    }
-
     class TypeParameterSymbol(index: Int) : ConeTypeParameterSymbol {
         override val name: Name = Name.identifier("T$index")
     }
 
-    override val kind: ClassKind
-        get() = ClassKind.INTERFACE
-
-    override val superTypes: List<ConeClassLikeType>
-        get() = emptyList() // TODO: kotlin.Function ???
 }

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

@@ -5,22 +5,9 @@
 
 package org.jetbrains.kotlin.fir.symbols.impl
 
-import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.name.ClassId
 
-class FirClassSymbol(override val classId: ClassId) : ConeClassSymbol, AbstractFirBasedSymbol<FirRegularClass>() {
-    override val kind: ClassKind
-        get() = fir.classKind
-
-    override val superTypes: List<ConeClassLikeType>
-        get() = fir.superTypes.mapNotNull { it.coneTypeSafe<ConeClassLikeType>() }
-
-    override val typeParameters: List<ConeTypeParameterSymbol>
-        get() = fir.typeParameters.map { it.symbol }
-}
+class FirClassSymbol(override val classId: ClassId) : ConeClassSymbol, AbstractFirBasedSymbol<FirRegularClass>()

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

@@ -8,15 +8,6 @@ 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.symbols.ConeTypeParameterSymbol
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.name.ClassId
 
-class FirTypeAliasSymbol(override val classId: ClassId) : ConeTypeAliasSymbol, AbstractFirBasedSymbol<FirTypeAlias>() {
-    override val typeParameters: List<ConeTypeParameterSymbol>
-        get() = fir.typeParameters.map { it.symbol }
-    override val expansionType: ConeClassLikeType?
-        get() = fir.expandedType.coneTypeSafe()
-
-}
+class FirTypeAliasSymbol(override val classId: ClassId) : ConeTypeAliasSymbol, AbstractFirBasedSymbol<FirTypeAlias>()