Refactor FIR symbols to make them and their FIR element types more clear

This commit also fixes work with Java synthetic properties

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

@@ -328,7 +328,7 @@ class MultiModuleHtmlFirDump(private val outputRoot: File) {
                     symbolIds[symbolOwner.symbol] = symbolCounter++
                 }
 
-                override fun visitVariable(variable: FirVariable) {
+                override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>) {
                     indexDeclaration(variable)
                     super.visitVariable(variable)
                 }
@@ -696,7 +696,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
                 generate(type.directExpansionType(session) ?: ConeKotlinErrorType("No expansion for type-alias"))
             }
             is ConeTypeParameterType -> resolved {
-                symbolRef(type.lookupTag.toSymbol(session)) {
+                symbolRef(type.lookupTag.toSymbol()) {
                     simpleName(type.lookupTag.name)
                 }
             }
@@ -794,7 +794,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         +"> "
     }
 
-    private fun FlowContent.generateReceiver(declaration: FirCallableDeclaration) {
+    private fun FlowContent.generateReceiver(declaration: FirCallableDeclaration<*>) {
         generateReceiver(declaration.receiverTypeRef)
     }
 
@@ -873,13 +873,13 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
             is FirWhenExpression -> generate(statement, isStatement = true)
             is FirTryExpression -> generate(statement, isStatement = true)
             is FirExpression -> iline { generate(statement) }
-            is FirVariable -> iline { generate(statement) }
+            is FirVariable<*> -> iline { generate(statement) }
             is FirVariableAssignment -> iline { generate(statement) }
             else -> unsupported(statement)
         }
     }
 
-    private fun FlowContent.generate(variable: FirVariable) {
+    private fun FlowContent.generate(variable: FirVariable<*>) {
         if (variable.isVal) {
             keyword("val ")
         } else {

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

@@ -104,10 +104,11 @@ fun FirReference.toSymbol(declarationStorage: Fir2IrDeclarationStorage): IrSymbo
 fun FirNamedReference.toSymbol(declarationStorage: Fir2IrDeclarationStorage): IrSymbol? {
     if (this is FirResolvedCallableReference) {
         when (val callableSymbol = this.coneSymbol) {
-            is FirFunctionSymbol -> return callableSymbol.toFunctionSymbol(declarationStorage)
+            is FirFunctionSymbol<*> -> return callableSymbol.toFunctionSymbol(declarationStorage)
             is FirPropertySymbol -> return callableSymbol.toPropertyOrFieldSymbol(declarationStorage)
+            is FirFieldSymbol -> return callableSymbol.toPropertyOrFieldSymbol(declarationStorage)
             is FirBackingFieldSymbol -> return callableSymbol.toPropertyOrFieldSymbol(declarationStorage)
-            is FirVariableSymbol -> return callableSymbol.toValueSymbol(declarationStorage)
+            is FirVariableSymbol<*> -> return callableSymbol.toValueSymbol(declarationStorage)
         }
     }
     return null
@@ -121,14 +122,14 @@ fun FirTypeParameterSymbol.toTypeParameterSymbol(declarationStorage: Fir2IrDecla
     return declarationStorage.getIrTypeParameterSymbol(this)
 }
 
-fun FirFunctionSymbol.toFunctionSymbol(declarationStorage: Fir2IrDeclarationStorage): IrFunctionSymbol {
+fun FirFunctionSymbol<*>.toFunctionSymbol(declarationStorage: Fir2IrDeclarationStorage): IrFunctionSymbol {
     return declarationStorage.getIrFunctionSymbol(this)
 }
 
-fun FirVariableSymbol.toPropertyOrFieldSymbol(declarationStorage: Fir2IrDeclarationStorage): IrSymbol {
+fun FirVariableSymbol<*>.toPropertyOrFieldSymbol(declarationStorage: Fir2IrDeclarationStorage): IrSymbol {
     return declarationStorage.getIrPropertyOrFieldSymbol(this)
 }
 
-fun FirVariableSymbol.toValueSymbol(declarationStorage: Fir2IrDeclarationStorage): IrValueSymbol {
+fun FirVariableSymbol<*>.toValueSymbol(declarationStorage: Fir2IrDeclarationStorage): IrValueSymbol {
     return declarationStorage.getIrValueSymbol(this)
 }

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

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.ir.declarations.*
 class Fir2IrCallableCache {
     private val parameterCache = mutableMapOf<FirValueParameter, IrValueParameter>()
 
-    private val variableCache = mutableMapOf<FirVariable, IrVariable>()
+    private val variableCache = mutableMapOf<FirVariable<*>, IrVariable>()
 
     private val localClassCache = mutableMapOf<FirClass, IrClass>()
 
@@ -25,9 +25,9 @@ class Fir2IrCallableCache {
         parameterCache[firParameter] = irParameter
     }
 
-    fun getVariable(variable: FirVariable): IrVariable? = variableCache[variable]
+    fun getVariable(variable: FirVariable<*>): IrVariable? = variableCache[variable]
 
-    fun putVariable(firVariable: FirVariable, irVariable: IrVariable) {
+    fun putVariable(firVariable: FirVariable<*>, irVariable: IrVariable) {
         variableCache[firVariable] = irVariable
     }
 

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

@@ -197,7 +197,7 @@ class Fir2IrDeclarationStorage(
         }
     }
 
-    internal fun findIrParent(callableMemberDeclaration: FirCallableMemberDeclaration): IrDeclarationParent? {
+    internal fun findIrParent(callableMemberDeclaration: FirCallableMemberDeclaration<*>): IrDeclarationParent? {
         val firBasedSymbol = callableMemberDeclaration.symbol
         val callableId = firBasedSymbol.callableId
         val parentClassId = callableId.classId
@@ -449,7 +449,7 @@ class Fir2IrDeclarationStorage(
         }
     }
 
-    fun createAndSaveIrVariable(variable: FirVariable): IrVariable {
+    fun createAndSaveIrVariable(variable: FirVariable<*>): IrVariable {
         val type = variable.returnTypeRef.toIrType(session, this)
         val irVariable = variable.convertWithOffsets { startOffset, endOffset ->
             declareIrVariable(
@@ -479,9 +479,9 @@ class Fir2IrDeclarationStorage(
         return irSymbolTable.referenceTypeParameter(irTypeParameter.descriptor)
     }
 
-    fun getIrFunctionSymbol(firFunctionSymbol: FirFunctionSymbol): IrFunctionSymbol {
+    fun getIrFunctionSymbol(firFunctionSymbol: FirFunctionSymbol<*>): IrFunctionSymbol {
         val firDeclaration = firFunctionSymbol.fir
-        val irParent = (firDeclaration as? FirCallableMemberDeclaration)?.let { findIrParent(it) }
+        val irParent = (firDeclaration as? FirCallableMemberDeclaration<*>)?.let { findIrParent(it) }
         return when (firDeclaration) {
             is FirNamedFunction -> {
                 val irDeclaration = getIrFunction(firDeclaration, irParent, shouldLeaveScope = true).apply {
@@ -499,7 +499,7 @@ class Fir2IrDeclarationStorage(
         }
     }
 
-    fun getIrPropertyOrFieldSymbol(firVariableSymbol: FirVariableSymbol): IrSymbol {
+    fun getIrPropertyOrFieldSymbol(firVariableSymbol: FirVariableSymbol<*>): IrSymbol {
         return when (val fir = firVariableSymbol.fir) {
             is FirProperty -> {
                 val irProperty = getIrProperty(fir).apply {
@@ -517,13 +517,13 @@ class Fir2IrDeclarationStorage(
         }
     }
 
-    private fun getIrVariableSymbol(firVariable: FirVariable): IrVariableSymbol {
+    private fun getIrVariableSymbol(firVariable: FirVariable<*>): IrVariableSymbol {
         val irDeclaration = localStorage.getVariable(firVariable)
             ?: throw IllegalArgumentException("Cannot find variable ${firVariable.render()} in local storage")
         return irSymbolTable.referenceVariable(irDeclaration.descriptor)
     }
 
-    fun getIrValueSymbol(firVariableSymbol: FirVariableSymbol): IrValueSymbol {
+    fun getIrValueSymbol(firVariableSymbol: FirVariableSymbol<*>): IrValueSymbol {
         return when (val firDeclaration = firVariableSymbol.fir) {
             is FirValueParameter -> {
                 val irDeclaration = localStorage.getParameter(firDeclaration)
@@ -531,10 +531,9 @@ class Fir2IrDeclarationStorage(
                     ?: return getIrVariableSymbol(firDeclaration)
                 irSymbolTable.referenceValueParameter(irDeclaration.descriptor)
             }
-            is FirVariable -> {
+            else -> {
                 getIrVariableSymbol(firDeclaration)
             }
-            else -> throw AssertionError("Should not be here")
         }
     }
 }

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

@@ -32,7 +32,7 @@ class Fir2IrLocalStorage {
         return null
     }
 
-    fun getVariable(variable: FirVariable): IrVariable? {
+    fun getVariable(variable: FirVariable<*>): IrVariable? {
         for (cache in cacheStack.asReversed()) {
             val local = cache.getVariable(variable)
             if (local != null) return local
@@ -60,7 +60,7 @@ class Fir2IrLocalStorage {
         cacheStack.last().putParameter(firParameter, irParameter)
     }
 
-    fun putVariable(firVariable: FirVariable, irVariable: IrVariable) {
+    fun putVariable(firVariable: FirVariable<*>, irVariable: IrVariable) {
         cacheStack.last().putVariable(firVariable, irVariable)
     }
 

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

@@ -21,13 +21,8 @@ import org.jetbrains.kotlin.fir.resolve.buildUseSiteScope
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTagImpl
-import org.jetbrains.kotlin.fir.symbols.ConeClassifierLookupTag
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -207,8 +202,8 @@ internal class Fir2IrVisitor(
             processedFunctionNames += name
             useSiteScope.processFunctionsByName(name) { functionSymbol ->
                 // TODO: think about overloaded functions. May be we should process all names.
-                if (functionSymbol is FirFunctionSymbol) {
+                if (functionSymbol is FirNamedFunctionSymbol) {
-                    val originalFunction = functionSymbol.fir as FirNamedFunction
+                    val originalFunction = functionSymbol.fir
                     val origin = IrDeclarationOrigin.FAKE_OVERRIDE
                     if (functionSymbol.isFakeOverride) {
                         // Substitution case
@@ -222,7 +217,7 @@ internal class Fir2IrVisitor(
                     } else if (fakeOverrideMode != FakeOverrideMode.SUBSTITUTION) {
                         // Trivial fake override case
                         val fakeOverrideSymbol = FirClassSubstitutionScope.createFakeOverride(session, originalFunction, functionSymbol)
-                        val fakeOverrideFunction = fakeOverrideSymbol.fir as FirNamedFunction
+                        val fakeOverrideFunction = fakeOverrideSymbol.fir
 
                         val irFunction = declarationStorage.getIrFunction(
                             fakeOverrideFunction, declarationStorage.findIrParent(originalFunction), origin = origin
@@ -278,7 +273,7 @@ internal class Fir2IrVisitor(
     private fun <T : IrFunction> T.setFunctionContent(
         descriptor: FunctionDescriptor,
         firFunction: FirFunction,
-        firOverriddenSymbol: FirFunctionSymbol? = null
+        firOverriddenSymbol: FirNamedFunctionSymbol? = null
     ): T {
         setParentByParentStack()
         withParent {
@@ -395,23 +390,25 @@ internal class Fir2IrVisitor(
         // TODO: find delegated constructor correctly
         val classId = constructedClassSymbol.classId
         val provider = this@Fir2IrVisitor.session.service<FirSymbolProvider>()
-        var constructorSymbol: FirCallableSymbol? = null
+        var constructorSymbol: FirConstructorSymbol? = null
         provider.getClassUseSiteMemberScope(classId, this@Fir2IrVisitor.session, ScopeSession())!!.processFunctionsByName(
             classId.shortClassName
         ) {
-            if (arguments.size <= ((it as FirFunctionSymbol).fir as FirFunction).valueParameters.size) {
+            when {
-                constructorSymbol = it
+                it !is FirConstructorSymbol -> ProcessorAction.NEXT
-                ProcessorAction.STOP
+                arguments.size <= it.fir.valueParameters.size -> {
-            } else {
+                    constructorSymbol = it
-                ProcessorAction.NEXT
+                    ProcessorAction.STOP
+                }
+                else -> ProcessorAction.NEXT
             }
         }
-        if (constructorSymbol == null) return null
+        val foundConstructorSymbol = constructorSymbol ?: return null
         return convertWithOffsets { startOffset, endOffset ->
             IrDelegatingConstructorCallImpl(
                 startOffset, endOffset,
                 constructedIrType,
-                declarationStorage.getIrFunctionSymbol(constructorSymbol as FirFunctionSymbol) as IrConstructorSymbol
+                declarationStorage.getIrFunctionSymbol(foundConstructorSymbol) as IrConstructorSymbol
             ).apply {
                 for ((index, argument) in arguments.withIndex()) {
                     val argumentExpression = argument.toIrExpression()
@@ -459,7 +456,7 @@ internal class Fir2IrVisitor(
         }
     }
 
-    override fun visitVariable(variable: FirVariable, data: Any?): IrElement {
+    override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>, data: Any?): IrElement {
         val irVariable = declarationStorage.createAndSaveIrVariable(variable)
         return irVariable.setParentByParentStack().apply {
             val initializer = variable.initializer

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

@@ -21,17 +21,11 @@ import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
 import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope
 import org.jetbrains.kotlin.fir.java.scopes.JavaClassUseSiteScope
 import org.jetbrains.kotlin.fir.resolve.*
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
 import org.jetbrains.kotlin.fir.symbols.CallableId
-import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
@@ -59,7 +53,7 @@ class JavaSymbolProvider(
         content: KotlinClassFinder.Result.ClassFileContent?
     ): JavaClass? = facade.findClass(JavaClassFinder.Request(classId, previouslyFoundClassFileContent = content?.content), searchScope)
 
-    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<ConeCallableSymbol> =
+    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> =
         emptyList()
 
     override fun getClassDeclaredMemberScope(classId: ClassId): FirScope? {
@@ -72,9 +66,8 @@ class JavaSymbolProvider(
         useSiteSession: FirSession,
         scopeSession: ScopeSession
     ): FirScope? {
-        val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null
+        val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null
-        val javaClass = symbol.firUnsafe<FirJavaClass>()
+        return buildJavaEnhancementScope(useSiteSession, symbol, scopeSession)
-        return buildJavaEnhancementScope(useSiteSession, javaClass.symbol, scopeSession)
     }
 
     private fun buildJavaEnhancementScope(
@@ -140,9 +133,9 @@ class JavaSymbolProvider(
             }
     }
 
-    override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? = getFirJavaClass(classId)
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? = getFirJavaClass(classId)
 
-    fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): ConeClassLikeSymbol? {
+    fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): FirClassLikeSymbol<*>? {
         if (!hasTopLevelClassOf(classId)) return null
         return classCache.lookupCacheOrCalculateWithPostCompute(classId, {
             val foundClass = findClass(classId, content)
@@ -197,7 +190,7 @@ class JavaSymbolProvider(
                     for (javaMethod in javaClass.methods) {
                         val methodName = javaMethod.name
                         val methodId = CallableId(classId.packageFqName, classId.relativeClassName, methodName)
-                        val methodSymbol = FirFunctionSymbol(methodId)
+                        val methodSymbol = FirNamedFunctionSymbol(methodId)
                         val returnType = javaMethod.returnType
                         val firJavaMethod = FirJavaMethod(
                             this@JavaSymbolProvider.session, methodSymbol, methodName,
@@ -219,7 +212,7 @@ class JavaSymbolProvider(
                     val constructorId = CallableId(classId.packageFqName, classId.relativeClassName, classId.shortClassName)
 
                     fun addJavaConstructor(visibility: Visibility = Visibilities.PUBLIC): FirJavaConstructor {
-                        val constructorSymbol = FirFunctionSymbol(constructorId)
+                        val constructorSymbol = FirConstructorSymbol(constructorId)
                         val classTypeParameters = javaClass.typeParameters.convertTypeParameters(javaTypeParameterStack)
                         val firJavaConstructor = FirJavaConstructor(
                             this@JavaSymbolProvider.session, constructorSymbol, visibility,

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

@@ -14,15 +14,15 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirAbstractCallableMember
 import org.jetbrains.kotlin.fir.declarations.impl.FirConstructorImpl.Companion.NAME
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 
 class FirJavaConstructor(
     session: FirSession,
-    override val symbol: FirFunctionSymbol,
+    override val symbol: FirConstructorSymbol,
     visibility: Visibility,
     delegatedSelfTypeRef: FirTypeRef
-) : FirAbstractCallableMember(
+) : FirAbstractCallableMember<FirConstructor>(
     session,
     psi = null,
     name = NAME,

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

@@ -11,21 +11,20 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirField
 import org.jetbrains.kotlin.fir.declarations.impl.FirAbstractCallableMember
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef
+import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 
 class FirJavaField(
     session: FirSession,
-    override val symbol: FirPropertySymbol,
+    override val symbol: FirFieldSymbol,
     name: Name,
     visibility: Visibility,
     modality: Modality?,
     returnTypeRef: FirTypeRef,
     override val isVar: Boolean,
     isStatic: Boolean
-) : FirAbstractCallableMember(
+) : FirAbstractCallableMember<FirField>(
     session, psi = null, name = name,
     visibility = visibility, modality = modality,
     isExpect = false, isActual = false, isOverride = false,

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

@@ -10,13 +10,12 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.impl.FirMemberFunctionImpl
 import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
-import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 
 class FirJavaMethod(
     session: FirSession,
-    symbol: FirFunctionSymbol,
+    symbol: FirNamedFunctionSymbol,
     name: Name,
     visibility: Visibility,
     modality: Modality?,

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

@@ -24,16 +24,15 @@ import org.jetbrains.kotlin.fir.java.topLevelName
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
 import org.jetbrains.kotlin.fir.resolve.*
-import org.jetbrains.kotlin.fir.resolve.transformers.firSafeNullable
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
 import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.*
 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.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.load.java.JavaClassFinder
@@ -145,12 +144,12 @@ class KotlinDeserializedJvmSymbolsProvider(
         useSiteSession: FirSession,
         scopeSession: ScopeSession
     ): FirScope? {
-        val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null
+        val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null
 
-        return symbol.firSafeNullable<FirRegularClass>()?.buildDefaultUseSiteScope(session, scopeSession)
+        return symbol.fir.buildDefaultUseSiteScope(session, scopeSession)
     }
 
-    override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? {
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? {
         return findAndDeserializeClass(classId) ?: findAndDeserializeTypeAlias(classId)
     }
 
@@ -316,8 +315,7 @@ class KotlinDeserializedJvmSymbolsProvider(
 
         if (classId in handledByJava) return null
 
-        val result = kotlinClassFinder.findKotlinClassOrContent(classId)
+        val kotlinJvmBinaryClass = when (val result = kotlinClassFinder.findKotlinClassOrContent(classId)) {
-        val kotlinJvmBinaryClass = when (result) {
             is KotlinClassFinder.Result.KotlinClass -> result.kotlinJvmBinaryClass
             is KotlinClassFinder.Result.ClassFileContent -> {
                 handledByJava.add(classId)
@@ -360,7 +358,7 @@ class KotlinDeserializedJvmSymbolsProvider(
 //        }
     }
 
-    private fun loadFunctionsByName(part: PackagePartsCacheData, name: Name): List<FirCallableSymbol> {
+    private fun loadFunctionsByName(part: PackagePartsCacheData, name: Name): List<FirCallableSymbol<*>> {
         val functionIds = part.topLevelFunctionNameIndex[name] ?: return emptyList()
         return functionIds.map { part.proto.getFunction(it) }
             .map {
@@ -370,7 +368,7 @@ class KotlinDeserializedJvmSymbolsProvider(
             }
     }
 
-    private fun loadPropertiesByName(part: PackagePartsCacheData, name: Name): List<FirCallableSymbol> {
+    private fun loadPropertiesByName(part: PackagePartsCacheData, name: Name): List<FirCallableSymbol<*>> {
         val propertyIds = part.topLevelPropertyNameIndex[name] ?: return emptyList()
         return propertyIds.map { part.proto.getProperty(it) }
             .map {
@@ -380,7 +378,7 @@ class KotlinDeserializedJvmSymbolsProvider(
             }
     }
 
-    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<ConeCallableSymbol> {
+    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> {
         return getPackageParts(packageFqName).flatMap { part ->
             loadFunctionsByName(part, name) + loadPropertiesByName(part, name)
         }

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

@@ -163,7 +163,7 @@ private fun JavaClassifierType.enhanceInflexibleType(
             arg.toConeProjection(
                 session,
                 javaTypeParameterStack,
-                ((originalTag as? FirBasedSymbol<*>)?.fir as? FirCallableMemberDeclaration)?.typeParameters?.getOrNull(localArgIndex)
+                ((originalTag as? FirBasedSymbol<*>)?.fir as? FirCallableMemberDeclaration<*>)?.typeParameters?.getOrNull(localArgIndex)
             )
         } else {
             val argEnhancedTypeRef = arg.enhancePossiblyFlexible(session, javaTypeParameterStack, annotations, qualifiers, globalArgIndex)

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt

@@ -18,13 +18,10 @@ import org.jetbrains.kotlin.fir.java.enhancement.EnhancementSignatureParts
 import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType
 import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
 import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver
@@ -53,42 +50,42 @@ class JavaClassEnhancementScope(
     private val context: FirJavaEnhancementContext =
         FirJavaEnhancementContext(session) { null }.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, owner.annotations)
 
-    private val enhancements = mutableMapOf<ConeCallableSymbol, ConeCallableSymbol>()
+    private val enhancements = mutableMapOf<FirCallableSymbol<*>, FirCallableSymbol<*>>()
 
-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
         useSiteScope.processPropertiesByName(name) process@{ original ->
 
             val field = enhancements.getOrPut(original) { enhance(original, name) }
-            processor(field as ConeVariableSymbol)
+            processor(field)
         }
 
         return super.processPropertiesByName(name, processor)
     }
 
-    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
         useSiteScope.processFunctionsByName(name) process@{ original ->
 
             val function = enhancements.getOrPut(original) { enhance(original, name) }
-            processor(function as ConeFunctionSymbol)
+            processor(function as FirFunctionSymbol<*>)
         }
 
         return super.processFunctionsByName(name, processor)
     }
 
     private fun enhance(
-        original: ConeVariableSymbol,
+        original: FirCallableSymbol<*>,
         name: Name
-    ): ConeVariableSymbol {
+    ): FirCallableSymbol<*> {
-        when (val firElement = (original as FirBasedSymbol<*>).fir) {
+        when (val firElement = original.fir) {
             is FirJavaField -> {
                 if (firElement.returnTypeRef !is FirJavaTypeRef) return original
                 val memberContext = context.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, firElement.annotations)
                 val newReturnTypeRef = enhanceReturnType(firElement, emptyList(), memberContext, null)
 
-                val symbol = FirPropertySymbol(original.callableId)
+                val symbol = FirFieldSymbol(original.callableId)
                 with(firElement) {
                     FirJavaField(
-                        session,
+                        this@JavaClassEnhancementScope.session,
                         symbol,
                         name,
                         visibility,
@@ -116,23 +113,24 @@ class JavaClassEnhancementScope(
     }
 
     private fun enhance(
-        original: ConeFunctionSymbol,
+        original: FirFunctionSymbol<*>,
         name: Name
-    ): FirFunctionSymbol {
+    ): FirFunctionSymbol<*> {
-        val firMethod = (original as FirFunctionSymbol).fir as? FirFunction
+        val firMethod = original.fir
 
-        if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor || firMethod !is FirCallableMemberDeclaration) return original
+        if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor) {
-        return enhanceMethod(firMethod, original.callableId, name) as FirFunctionSymbol
+            return original
+        }
+        return enhanceMethod(firMethod, original.callableId, name)
     }
 
     private fun enhanceMethod(
-        firMethod: FirFunction,
+        firMethod: FirMemberFunction<*>,
         methodId: CallableId,
         name: Name,
         isAccessor: Boolean = false,
         propertyId: CallableId? = null
-    ): ConeCallableSymbol {
+    ): FirFunctionSymbol<*> {
-        require(firMethod is FirCallableMemberDeclaration)
         val memberContext = context.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, firMethod.annotations)
 
         val predefinedEnhancementInfo =
@@ -169,7 +167,6 @@ class JavaClassEnhancementScope(
             )
         }
 
-        val symbol = if (!isAccessor) FirFunctionSymbol(methodId) else FirAccessorSymbol(callableId = propertyId!!, accessorId = methodId)
         val newValueParameters = firMethod.valueParameters.zip(newValueParameterInfo) { valueParameter, newInfo ->
             val (newTypeRef, newDefaultValue) = newInfo
             with(valueParameter) {
@@ -182,27 +179,29 @@ class JavaClassEnhancementScope(
                 }
             }
         }
-        val function = when (firMethod) {
+        val function: FirMemberFunction<*> = when (firMethod) {
             is FirJavaConstructor -> FirConstructorImpl(
-                this@JavaClassEnhancementScope.session, null, symbol as FirFunctionSymbol,
+                this@JavaClassEnhancementScope.session, null, FirConstructorSymbol(methodId),
                 newReceiverTypeRef, newReturnTypeRef
             ).apply {
                 this.valueParameters += newValueParameters
                 this.typeParameters += firMethod.typeParameters
             }
             else -> FirMemberFunctionImpl(
-                this@JavaClassEnhancementScope.session, null, symbol, name,
+                this@JavaClassEnhancementScope.session, null,
-                newReceiverTypeRef, newReturnTypeRef
+                if (!isAccessor) FirNamedFunctionSymbol(methodId)
+                else FirAccessorSymbol(callableId = propertyId!!, accessorId = methodId),
+                name, newReceiverTypeRef, newReturnTypeRef
             ).apply {
                 this.valueParameters += newValueParameters
                 this.typeParameters += firMethod.typeParameters
             }
         }
-        function.apply {
+        (function as FirAbstractCallableMember<*>).apply {
             status = firMethod.status as FirDeclarationStatusImpl
             annotations += firMethod.annotations
         }
-        return symbol
+        return function.symbol
     }
 
     private fun FirFunction.computeJvmDescriptor(): String = buildString {
@@ -255,7 +254,7 @@ class JavaClassEnhancementScope(
 
     private fun enhanceReceiverType(
         ownerFunction: FirJavaMethod,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
         memberContext: FirJavaEnhancementContext
     ): FirResolvedTypeRef {
         val signatureParts = ownerFunction.partsForValueParameter(
@@ -272,8 +271,8 @@ class JavaClassEnhancementScope(
     private data class EnhanceValueParameterResult(val typeRef: FirResolvedTypeRef, val defaultValue: FirExpression?)
 
     private fun enhanceValueParameter(
-        ownerFunction: FirCallableMemberDeclaration,
+        ownerFunction: FirCallableMemberDeclaration<*>,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
         hasReceiver: Boolean,
         memberContext: FirJavaEnhancementContext,
         predefinedEnhancementInfo: PredefinedFunctionEnhancementInfo?,
@@ -297,8 +296,8 @@ class JavaClassEnhancementScope(
     }
 
     private fun enhanceReturnType(
-        owner: FirCallableMemberDeclaration,
+        owner: FirCallableMemberDeclaration<*>,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
         memberContext: FirJavaEnhancementContext,
         predefinedEnhancementInfo: PredefinedFunctionEnhancementInfo?
     ): FirResolvedTypeRef {
@@ -315,9 +314,9 @@ class JavaClassEnhancementScope(
         return signatureParts.type
     }
 
-    private val overrideBindCache = mutableMapOf<Name, Map<ConeCallableSymbol?, List<ConeCallableSymbol>>>()
+    private val overrideBindCache = mutableMapOf<Name, Map<FirCallableSymbol<*>?, List<FirCallableSymbol<*>>>>()
 
-    private fun FirCallableMemberDeclaration.overriddenMembers(): List<FirCallableMemberDeclaration> {
+    private fun FirCallableMemberDeclaration<*>.overriddenMembers(): List<FirCallableMemberDeclaration<*>> {
         val backMap = overrideBindCache.getOrPut(this.name) {
             useSiteScope.bindOverrides(this.name)
             useSiteScope
@@ -325,36 +324,36 @@ class JavaClassEnhancementScope(
                 .toList()
                 .groupBy({ (_, key) -> key }, { (value) -> value })
         }
-        return backMap[this.symbol]?.map { it.firUnsafe() } ?: emptyList()
+        return backMap[this.symbol]?.map { it.fir as FirCallableMemberDeclaration<*> } ?: emptyList()
     }
 
     private sealed class TypeInSignature {
-        abstract fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef
+        abstract fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef
 
         object Return : TypeInSignature() {
-            override fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef = member.returnTypeRef
+            override fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef = member.returnTypeRef
         }
 
         object Receiver : TypeInSignature() {
-            override fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef {
+            override fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef {
                 if (member is FirJavaMethod) return member.valueParameters[0].returnTypeRef
                 return member.receiverTypeRef!!
             }
         }
 
         class ValueParameter(val hasReceiver: Boolean, val index: Int) : TypeInSignature() {
-            override fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef {
+            override fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef {
                 if (hasReceiver && member is FirJavaMethod) {
-                    return (member as FirFunction).valueParameters[index + 1].returnTypeRef
+                    return member.valueParameters[index + 1].returnTypeRef
                 }
                 return (member as FirFunction).valueParameters[index].returnTypeRef
             }
         }
     }
 
-    private fun FirCallableMemberDeclaration.partsForValueParameter(
+    private fun FirCallableMemberDeclaration<*>.partsForValueParameter(
         typeQualifierResolver: FirAnnotationTypeQualifierResolver,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
         // TODO: investigate if it's really can be a null (check properties' with extension overrides in Java)
         parameterContainer: FirAnnotationContainer?,
         methodContext: FirJavaEnhancementContext,
@@ -370,9 +369,9 @@ class JavaClassEnhancementScope(
         typeInSignature
     )
 
-    private fun FirCallableMemberDeclaration.parts(
+    private fun FirCallableMemberDeclaration<*>.parts(
         typeQualifierResolver: FirAnnotationTypeQualifierResolver,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
         typeContainer: FirAnnotationContainer?,
         isCovariant: Boolean,
         containerContext: FirJavaEnhancementContext,

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt

@@ -13,18 +13,12 @@ import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.*
 import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractProviderBasedScope
-import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol
 import org.jetbrains.kotlin.fir.symbols.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
@@ -42,7 +36,7 @@ class JavaClassUseSiteScope(
         if (klass is FirJavaClass) klass.javaTypeParameterStack else JavaTypeParameterStack.EMPTY
 
     //base symbol as key, overridden as value
-    internal val overriddenByBase = mutableMapOf<ConeCallableSymbol, ConeCallableSymbol?>()
+    internal val overriddenByBase = mutableMapOf<FirCallableSymbol<*>, FirCallableSymbol<*>?>()
 
     private val context: ConeTypeContext = session.typeContext
 
@@ -64,9 +58,8 @@ class JavaClassUseSiteScope(
             substitutor
         )
 
-    private fun isOverriddenFunCheck(overriddenInJava: FirFunction, base: FirFunction): Boolean {
+    private fun isOverriddenFunCheck(overriddenInJava: FirNamedFunction, base: FirNamedFunction): Boolean {
-        overriddenInJava as FirCallableMemberDeclaration
+        val receiverTypeRef = base.receiverTypeRef
-        val receiverTypeRef = (base as FirCallableMemberDeclaration).receiverTypeRef
         val baseParameterTypes = listOfNotNull(receiverTypeRef) + base.valueParameters.map { it.returnTypeRef }
 
         if (overriddenInJava.valueParameters.size != baseParameterTypes.size) return false
@@ -111,7 +104,7 @@ class JavaClassUseSiteScope(
     }
 
     internal fun bindOverrides(name: Name) {
-        val overrideCandidates = mutableSetOf<ConeFunctionSymbol>()
+        val overrideCandidates = mutableSetOf<FirFunctionSymbol<*>>()
         declaredMemberScope.processFunctionsByName(name) {
             overrideCandidates += it
             NEXT
@@ -124,29 +117,31 @@ class JavaClassUseSiteScope(
         }
     }
 
-    private fun ConeCallableSymbol.getOverridden(candidates: Set<ConeCallableSymbol>): ConeCallableSymbol? {
+    private fun FirCallableSymbol<*>.getOverridden(candidates: Set<FirCallableSymbol<*>>): FirCallableSymbol<*>? {
         if (overriddenByBase.containsKey(this)) return overriddenByBase[this]
 
         val overriding = when (this) {
-            is FirFunctionSymbol -> {
+            is FirNamedFunctionSymbol -> {
-                val self = firUnsafe<FirFunction>()
+                val self = this.fir
-                self as FirCallableMemberDeclaration
                 candidates.firstOrNull {
-                    val overridden = (it as? FirFunctionSymbol)?.fir as? FirFunction
+                    val overridden = (it as? FirNamedFunctionSymbol)?.fir
                     overridden != null && self.modality != Modality.FINAL && isOverriddenFunCheck(overridden, self)
                 }
             }
+            is FirConstructorSymbol, is FirFieldSymbol -> {
+                null
+            }
             is FirPropertySymbol -> {
-                val self = fir as? FirProperty ?: return null
+                val self = fir
                 candidates.firstOrNull {
                     when (it) {
-                        is FirFunctionSymbol -> {
+                        is FirNamedFunctionSymbol -> {
-                            val overridden = it.fir as FirNamedFunction
+                            val overridden = it.fir
                             self.modality != Modality.FINAL && isOverriddenPropertyCheck(overridden, self)
                         }
                         is FirPropertySymbol -> {
                             val overridden = it.fir
-                            overridden is FirProperty && self.modality != Modality.FINAL && isOverriddenPropertyCheck(overridden, self)
+                            self.modality != Modality.FINAL && isOverriddenPropertyCheck(overridden, self)
                         }
                         else -> false
                     }
@@ -154,9 +149,9 @@ class JavaClassUseSiteScope(
                 }
             }
             is FirAccessorSymbol -> {
-                val self = fir as FirNamedFunction
+                val self = fir
                 candidates.firstOrNull {
-                    val overridden = (it as? FirFunctionSymbol)?.fir as? FirNamedFunction
+                    val overridden = (it as? FirNamedFunctionSymbol)?.fir
                     overridden != null && self.modality != Modality.FINAL && isOverriddenFunCheck(overridden, self)
                 }
             }
@@ -167,8 +162,8 @@ class JavaClassUseSiteScope(
         return overriding
     }
 
-    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
-        val overrideCandidates = mutableSetOf<ConeFunctionSymbol>()
+        val overrideCandidates = mutableSetOf<FirFunctionSymbol<*>>()
         if (!declaredMemberScope.processFunctionsByName(name) {
                 overrideCandidates += it
                 processor(it)
@@ -190,9 +185,9 @@ class JavaClassUseSiteScope(
         propertyName: Name,
         accessorName: Name,
         isGetter: Boolean,
-        processor: (ConeVariableSymbol) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> ProcessorAction
     ): ProcessorAction {
-        val overrideCandidates = mutableSetOf<ConeCallableSymbol>()
+        val overrideCandidates = mutableSetOf<FirCallableSymbol<*>>()
         val klass = symbol.fir
         if (!declaredMemberScope.processPropertiesByName(propertyName) { variableSymbol ->
                 overrideCandidates += variableSymbol
@@ -201,19 +196,17 @@ class JavaClassUseSiteScope(
         ) return STOP
         if (klass is FirJavaClass) {
             if (!declaredMemberScope.processFunctionsByName(accessorName) { functionSymbol ->
-                    if (functionSymbol is FirFunctionSymbol) {
+                    if (functionSymbol is FirNamedFunctionSymbol) {
                         val fir = functionSymbol.fir
-                        if (fir is FirNamedFunction) {
+                        if (fir.isStatic) {
-                            if (fir.isStatic) {
+                            return@processFunctionsByName NEXT
+                        }
+                        when (isGetter) {
+                            true -> if (fir.valueParameters.isNotEmpty()) {
                                 return@processFunctionsByName NEXT
                             }
-                            when (isGetter) {
+                            false -> if (fir.valueParameters.size != 1) {
-                                true -> if (fir.valueParameters.isNotEmpty()) {
+                                return@processFunctionsByName NEXT
-                                    return@processFunctionsByName NEXT
-                                }
-                                false -> if (fir.valueParameters.size != 1) {
-                                    return@processFunctionsByName NEXT
-                                }
                             }
                         }
                     }
@@ -222,8 +215,8 @@ class JavaClassUseSiteScope(
                         accessorId = functionSymbol.callableId,
                         callableId = CallableId(functionSymbol.callableId.packageName, functionSymbol.callableId.className, propertyName)
                     )
-                    if (functionSymbol is FirBasedSymbol<*>) {
+                    if (functionSymbol is FirNamedFunctionSymbol) {
-                        (functionSymbol.fir as? FirCallableMemberDeclaration)?.let { callableMember -> accessorSymbol.bind(callableMember) }
+                        functionSymbol.fir.let { callableMember -> accessorSymbol.bind(callableMember) }
                     }
                     processor(accessorSymbol)
                 }
@@ -231,12 +224,12 @@ class JavaClassUseSiteScope(
         }
 
         return superTypesScope.processPropertiesByName(propertyName) {
-            val firCallableMember = (it as FirBasedSymbol<*>).fir as? FirCallableMemberDeclaration
+            val firCallableMember = it.fir as? FirCallableMemberDeclaration<*>
             if (firCallableMember?.isStatic == true) {
                 NEXT
             } else {
                 val overriddenBy = it.getOverridden(overrideCandidates)
-                if (overriddenBy == null && it is ConePropertySymbol) {
+                if (overriddenBy == null && it is FirVariableSymbol<*>) {
                     processor(it)
                 } else {
                     NEXT
@@ -245,7 +238,7 @@ class JavaClassUseSiteScope(
         }
     }
 
-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
         val getterName = Name.identifier(getterPrefix + name.asString().capitalize())
         return processAccessorFunctionsAndPropertiesByName(name, getterName, isGetter = true, processor = processor)
     }

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

@@ -431,7 +431,7 @@ internal fun generateAccessExpression(session: FirSession, psi: PsiElement?, nam
         calleeReference = FirSimpleNamedReference(session, psi, name)
     }
 
-internal fun generateResolvedAccessExpression(session: FirSession, psi: PsiElement?, variable: FirVariable): FirQualifiedAccessExpression =
+internal fun generateResolvedAccessExpression(session: FirSession, psi: PsiElement?, variable: FirVariable<*>): FirQualifiedAccessExpression =
     FirQualifiedAccessExpressionImpl(session, psi).apply {
         calleeReference = FirResolvedCallableReferenceImpl(session, psi, variable.name, variable.symbol)
     }
@@ -439,7 +439,7 @@ internal fun generateResolvedAccessExpression(session: FirSession, psi: PsiEleme
 internal fun generateDestructuringBlock(
     session: FirSession,
     multiDeclaration: KtDestructuringDeclaration,
-    container: FirVariable,
+    container: FirVariable<*>,
     tmpVariable: Boolean,
     extractAnnotationsTo: KtAnnotated.(FirAbstractAnnotatedElement) -> Unit,
     toFirOrImplicitTypeRef: KtTypeReference?.() -> FirTypeRef
@@ -465,14 +465,14 @@ internal fun generateDestructuringBlock(
 
 internal fun generateTemporaryVariable(
     session: FirSession, psi: PsiElement?, name: Name, initializer: FirExpression
-): FirVariable =
+): FirVariable<*> =
     FirVariableImpl(session, psi, name, FirImplicitTypeRefImpl(session, psi), false, initializer, FirVariableSymbol(name)).apply {
         symbol.bind(this)
     }
 
 internal fun generateTemporaryVariable(
     session: FirSession, psi: PsiElement?, specialName: String, initializer: FirExpression
-): FirVariable = generateTemporaryVariable(session, psi, Name.special("<$specialName>"), initializer)
+): FirVariable<*> = generateTemporaryVariable(session, psi, Name.special("<$specialName>"), initializer)
 
 private fun FirModifiableQualifiedAccess<*>.initializeLValue(
     session: FirSession,

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

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.expressions.impl.*
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
 import org.jetbrains.kotlin.fir.symbols.CallableId
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.name.FqName
@@ -35,7 +35,7 @@ internal fun KtClassOrObject.generateComponentFunctions(
         if (!ktParameter.hasValOrVar()) continue
         val name = Name.identifier("component$componentIndex")
         componentIndex++
-        val symbol = FirFunctionSymbol(CallableId(packageFqName, classFqName, name))
+        val symbol = FirNamedFunctionSymbol(CallableId(packageFqName, classFqName, name))
         firClass.addDeclaration(
             FirMemberFunctionImpl(
                 session, ktParameter, symbol, name,
@@ -76,7 +76,7 @@ internal fun KtClassOrObject.generateCopyFunction(
     firPrimaryConstructor: FirConstructor,
     toFirOrErrorTypeRef: KtTypeReference?.() -> FirTypeRef
 ) {
-    val symbol = FirFunctionSymbol(CallableId(packageFqName, classFqName, copyName))
+    val symbol = FirNamedFunctionSymbol(CallableId(packageFqName, classFqName, copyName))
     firClass.addDeclaration(
         FirMemberFunctionImpl(
             session, this, symbol, copyName,

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

@@ -403,7 +403,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
             val firConstructor = FirPrimaryConstructorImpl(
                 session,
                 this ?: owner,
-                FirFunctionSymbol(callableIdForClassConstructor()),
+                FirConstructorSymbol(callableIdForClassConstructor()),
                 this?.visibility ?: defaultVisibility(),
                 this?.hasExpectModifier() ?: false,
                 this?.hasActualModifier() ?: false,
@@ -625,7 +625,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
                 FirMemberFunctionImpl(
                     session,
                     function,
-                    FirFunctionSymbol(callableIdForName(function.nameAsSafeName, function.isLocal)),
+                    FirNamedFunctionSymbol(callableIdForName(function.nameAsSafeName, function.isLocal)),
                     function.nameAsSafeName,
                     if (function.isLocal) Visibilities.LOCAL else function.visibility,
                     function.modality,
@@ -713,7 +713,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
             val firConstructor = FirConstructorImpl(
                 session,
                 this,
-                FirFunctionSymbol(callableIdForClassConstructor()),
+                FirConstructorSymbol(callableIdForClassConstructor()),
                 visibility,
                 hasExpectModifier(),
                 hasActualModifier(),

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

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.deserialization
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.impl.FirClassImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirEnumEntryImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
@@ -57,7 +56,7 @@ fun deserializeClassToSymbol(
                 classId, classProto, nameResolver, session,
                 defaultAnnotationDeserializer ?: FirBuiltinAnnotationDeserializer(session)
             )
-        typeParameters += context.typeDeserializer.ownTypeParameters.map { it.firUnsafe() }
+        typeParameters += context.typeDeserializer.ownTypeParameters.map { it.fir }
         annotations += context.annotationDeserializer.loadClassAnnotations(classProto, context.nameResolver)
 
         val typeDeserializer = context.typeDeserializer

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

@@ -11,12 +11,8 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.*
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.symbols.CallableId
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
@@ -146,7 +142,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
                 emptyList() /* TODO */
             )
         ).apply {
-            typeParameters += local.typeDeserializer.ownTypeParameters.map { it.firUnsafe() }
+            typeParameters += local.typeDeserializer.ownTypeParameters.map { it.fir }
         }
     }
 
@@ -183,7 +179,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
             } else null,
             delegate = null
         ).apply {
-            typeParameters += local.typeDeserializer.ownTypeParameters.map { it.firUnsafe() }
+            typeParameters += local.typeDeserializer.ownTypeParameters.map { it.fir }
             annotations += c.annotationDeserializer.loadPropertyAnnotations(proto, local.nameResolver)
         }
     }
@@ -200,7 +196,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
             c.versionRequirementTable
 
         val callableName = c.nameResolver.getName(proto.name)
-        val symbol = FirFunctionSymbol(CallableId(c.packageFqName, c.relativeClassName, callableName))
+        val symbol = FirNamedFunctionSymbol(CallableId(c.packageFqName, c.relativeClassName, callableName))
         val local = c.childContext(proto.typeParameterList)
 
         // TODO: support contracts
@@ -223,7 +219,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
             receiverTypeRef = proto.receiverType(local.typeTable)?.toTypeRef(local),
             returnTypeRef = proto.returnType(local.typeTable).toTypeRef(local)
         ).apply {
-            typeParameters += local.typeDeserializer.ownTypeParameters.map { it.firUnsafe() }
+            typeParameters += local.typeDeserializer.ownTypeParameters.map { it.fir }
             valueParameters += local.memberDeserializer.valueParameters(proto.valueParameterList)
             annotations += local.annotationDeserializer.loadFunctionAnnotations(proto, local.nameResolver)
         }
@@ -232,7 +228,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
     fun loadConstructor(proto: ProtoBuf.Constructor, klass: FirRegularClass): FirConstructor {
         val flags = proto.flags
         val relativeClassName = c.relativeClassName!!
-        val symbol = FirFunctionSymbol(CallableId(c.packageFqName, relativeClassName, relativeClassName.shortName()))
+        val symbol = FirConstructorSymbol(CallableId(c.packageFqName, relativeClassName, relativeClassName.shortName()))
         val local = c.childContext(emptyList())
         val isPrimary = !Flags.IS_SECONDARY.get(flags)
 

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

@@ -8,10 +8,8 @@ package org.jetbrains.kotlin.fir.deserialization
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
 import org.jetbrains.kotlin.fir.resolve.toTypeProjection
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.symbols.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeAbbreviatedTypeImpl
@@ -68,11 +66,11 @@ class FirTypeDeserializer(
         }
     }
 
-    private val typeParameterDescriptors =
+    private val typeParameterDescriptors: Map<Int, FirTypeParameterSymbol> =
         if (typeParameterProtos.isEmpty()) {
-            mapOf<Int, ConeTypeParameterSymbol>()
+            mapOf()
         } else {
-            val result = LinkedHashMap<Int, ConeTypeParameterSymbol>()
+            val result = LinkedHashMap<Int, FirTypeParameterSymbol>()
             for ((index, proto) in typeParameterProtos.withIndex()) {
                 if (!proto.hasId()) continue
                 val name = nameResolver.getName(proto.name)
@@ -94,8 +92,8 @@ class FirTypeDeserializer(
     init {
         for ((index, proto) in typeParameterProtos.withIndex()) {
             if (!proto.hasId()) continue
-            val symbol = typeParameterDescriptors[proto.id] as FirTypeParameterSymbol
+            val symbol = typeParameterDescriptors[proto.id]!!
-            val declaration = symbol.firUnsafe<FirTypeParameterImpl>()
+            val declaration = symbol.fir as FirTypeParameterImpl
             declaration.apply {
                 proto.upperBoundList.mapTo(bounds) {
                     FirResolvedTypeRefImpl(session, null, type(it), emptyList())
@@ -104,17 +102,11 @@ class FirTypeDeserializer(
         }
     }
 
-    val ownTypeParameters: List<ConeTypeParameterSymbol>
+    val ownTypeParameters: List<FirTypeParameterSymbol>
         get() = typeParameterDescriptors.values.toList()
 
 
-    fun ConeClassLikeSymbol.typeParameters(): List<ConeTypeParameterSymbol> = when (this) {
+    fun FirClassLikeSymbol<*>.typeParameters(): List<ConeTypeParameterSymbol> = fir.typeParameters.map { it.symbol }
-        is FirTypeAliasSymbol -> fir.typeParameters
-        is FirClassSymbol -> fir.typeParameters
-        else -> error("?!id:2")
-    }.map {
-        it.symbol
-    }
 
     fun simpleType(proto: ProtoBuf.Type): ConeLookupTagBasedType? {
 

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

@@ -7,16 +7,16 @@ 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.ConeCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
+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() {
-    protected val classCache = HashMap<ClassId, ConeClassLikeSymbol?>()
+    protected val classCache = HashMap<ClassId, FirClassLikeSymbol<*>?>()
-    protected val topLevelCallableCache = HashMap<CallableId, List<ConeCallableSymbol>>()
+    protected val topLevelCallableCache = HashMap<CallableId, List<FirCallableSymbol<*>>>()
     protected val packageCache = HashMap<FqName, FqName?>()
 
     protected inline fun <K, V : Any?> MutableMap<K, V>.lookupCacheOrCalculate(key: K, crossinline l: (K) -> V): V? {

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

@@ -10,7 +10,8 @@ import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -18,9 +19,9 @@ import org.jetbrains.kotlin.name.Name
 abstract class FirProvider : FirSymbolProvider() {
     abstract fun getFirClassifierByFqName(fqName: ClassId): FirMemberDeclaration?
 
-    abstract override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol?
+    abstract override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>?
 
-    abstract override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<ConeCallableSymbol>
+    abstract override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>>
 
     override fun getPackage(fqName: FqName): FqName? {
         if (getFirFilesByPackage(fqName).isNotEmpty()) return fqName

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

@@ -11,13 +11,15 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
 abstract class FirSymbolProvider {
 
-    abstract fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol?
+    abstract fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>?
 
     fun getSymbolByLookupTag(lookupTag: ConeClassifierLookupTag): ConeClassifierSymbol? {
         return when (lookupTag) {
@@ -35,7 +37,7 @@ abstract class FirSymbolProvider {
         }
     }
 
-    abstract fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<ConeCallableSymbol>
+    abstract fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>>
 
     abstract fun getClassDeclaredMemberScope(classId: ClassId): FirScope?
     abstract fun getClassUseSiteMemberScope(

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

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeAbbreviatedTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
@@ -52,6 +53,8 @@ fun ConeClassifierLookupTag.toSymbol(useSiteSession: FirSession): ConeClassifier
         else -> error("sealed ${this::class}")
     }
 
+fun ConeTypeParameterLookupTag.toSymbol(): FirTypeParameterSymbol = this.symbol as FirTypeParameterSymbol
+
 fun ConeClassLikeLookupTag.constructClassType(typeArguments: Array<ConeKotlinTypeProjection>, isNullable: Boolean): ConeLookupTagBasedType {
     return ConeClassTypeImpl(this, typeArguments, isNullable)
 }

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

@@ -7,14 +7,11 @@ package org.jetbrains.kotlin.fir.resolve
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.resolve.transformers.firSafeNullable
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
@@ -33,8 +30,7 @@ fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession)
         }
         is ConeTypeParameterType -> {
             // TODO: support LibraryTypeParameterSymbol or get rid of it
-            val toSymbol = this.lookupTag.toSymbol(useSiteSession)?.takeIf { it is FirBasedSymbol<*> } ?: return null
+            val fir = lookupTag.toSymbol().fir
-            val fir = toSymbol.firUnsafe<FirTypeParameter>()
             FirCompositeScope(
                 fir.bounds.mapNotNullTo(mutableListOf()) {
                     it.coneTypeUnsafe<ConeKotlinType>().scope(useSiteSession, scopeSession)

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

@@ -85,7 +85,7 @@ fun FirRegularClass.buildDefaultUseSiteScope(useSiteSession: FirSession, builder
 private fun ConeClassLikeType.wrapSubstitutionScopeIfNeed(
     session: FirSession,
     useSiteScope: FirScope,
-    declaration: FirClassLikeDeclaration,
+    declaration: FirClassLikeDeclaration<*>,
     builder: ScopeSession
 ): FirScope {
     if (this.typeArguments.isEmpty()) return useSiteScope

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
 import org.jetbrains.kotlin.fir.expressions.impl.FirQualifiedAccessExpressionImpl
-import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.constructClassType
@@ -29,9 +28,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitSimpleImportingScope
 import org.jetbrains.kotlin.fir.scopes.processClassifiersByNameWithAction
 import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -93,7 +90,7 @@ class CheckerSinkImpl(override val components: InferenceComponents, var continua
 
 
 class Candidate(
-    val symbol: ConeSymbol,
+    val symbol: FirBasedSymbol<*>,
     val dispatchReceiverValue: ClassDispatchReceiverValue?,
     val implicitExtensionReceiverValue: ImplicitReceiverValue?,
     val explicitReceiverKind: ExplicitReceiverKind,
@@ -136,14 +133,14 @@ enum class TowerDataKind {
 
 interface TowerScopeLevel {
 
-    sealed class Token<out T : ConeSymbol> {
+    sealed class Token<out T : FirBasedSymbol<*>> {
-        object Properties : Token<ConePropertySymbol>()
+        object Properties : Token<FirPropertySymbol>()
 
-        object Functions : Token<ConeFunctionSymbol>()
+        object Functions : Token<FirFunctionSymbol<*>>()
-        object Objects : Token<ConeClassifierSymbol>()
+        object Objects : Token<FirBasedSymbol<*>>()
     }
 
-    fun <T : ConeSymbol> processElementsByName(
+    fun <T : FirBasedSymbol<*>> processElementsByName(
         token: Token<T>,
         name: Name,
         explicitReceiver: ExpressionReceiverValue?,
@@ -159,7 +156,7 @@ interface TowerScopeLevel {
     }
 
     object Empty : TowerScopeLevel {
-        override fun <T : ConeSymbol> processElementsByName(
+        override fun <T : FirBasedSymbol<*>> processElementsByName(
             token: Token<T>,
             name: Name,
             explicitReceiver: ExpressionReceiverValue?,
@@ -169,15 +166,15 @@ interface TowerScopeLevel {
 }
 
 abstract class SessionBasedTowerLevel(val session: FirSession) : TowerScopeLevel {
-    protected fun ConeSymbol.dispatchReceiverValue(): ClassDispatchReceiverValue? {
+    protected fun FirBasedSymbol<*>.dispatchReceiverValue(): ClassDispatchReceiverValue? {
         return when (this) {
-            is FirFunctionSymbol -> fir.dispatchReceiverValue(session)
+            is FirNamedFunctionSymbol -> fir.dispatchReceiverValue(session)
             is FirClassSymbol -> ClassDispatchReceiverValue(fir.symbol)
             else -> null
         }
     }
 
-    protected fun ConeCallableSymbol.hasConsistentExtensionReceiver(extensionReceiver: ReceiverValue?): Boolean {
+    protected fun FirCallableSymbol<*>.hasConsistentExtensionReceiver(extensionReceiver: ReceiverValue?): Boolean {
         val hasExtensionReceiver = hasExtensionReceiver()
         return hasExtensionReceiver == (extensionReceiver != null)
     }
@@ -196,7 +193,7 @@ class MemberScopeTowerLevel(
     val scopeSession: ScopeSession
 ) : SessionBasedTowerLevel(session) {
 
-    private fun <T : ConeSymbol> processMembers(
+    private fun <T : FirBasedSymbol<*>> processMembers(
         output: TowerScopeLevel.TowerScopeLevelProcessor<T>,
         explicitExtensionReceiver: ExpressionReceiverValue?,
         processScopeMembers: FirScope.(processor: (T) -> ProcessorAction) -> ProcessorAction
@@ -205,11 +202,11 @@ class MemberScopeTowerLevel(
         val extensionReceiver = implicitExtensionReceiver ?: explicitExtensionReceiver
         val scope = dispatchReceiver.type.scope(session, scopeSession) ?: return ProcessorAction.NEXT
         if (scope.processScopeMembers { candidate ->
-                if (candidate is ConeCallableSymbol && candidate.hasConsistentExtensionReceiver(extensionReceiver)) {
+                if (candidate is FirCallableSymbol<*> && candidate.hasConsistentExtensionReceiver(extensionReceiver)) {
                     // NB: we do not check dispatchReceiverValue != null here,
                     // because of objects & constructors (see comments in dispatchReceiverValue() implementation)
                     output.consumeCandidate(candidate, candidate.dispatchReceiverValue(), implicitExtensionReceiver)
-                } else if (candidate is ConeClassLikeSymbol) {
+                } else if (candidate is FirClassLikeSymbol<*>) {
                     output.consumeCandidate(candidate, null, implicitExtensionReceiver)
                 } else {
                     ProcessorAction.NEXT
@@ -222,7 +219,7 @@ class MemberScopeTowerLevel(
         }
     }
 
-    override fun <T : ConeSymbol> processElementsByName(
+    override fun <T : FirBasedSymbol<*>> processElementsByName(
         token: TowerScopeLevel.Token<T>,
         name: Name,
         explicitReceiver: ExpressionReceiverValue?,
@@ -244,7 +241,7 @@ class MemberScopeTowerLevel(
 
 }
 
-private fun ConeCallableSymbol.hasExtensionReceiver(): Boolean = (this as? FirCallableSymbol)?.fir?.receiverTypeRef != null
+private fun FirCallableSymbol<*>.hasExtensionReceiver(): Boolean = this.fir.receiverTypeRef != null
 
 // This is more like "scope-based tower level"
 // We can access here members of currently accessible scope which is not influenced by explicit receiver
@@ -258,7 +255,7 @@ class ScopeTowerLevel(
     val scope: FirScope,
     val implicitExtensionReceiver: ImplicitReceiverValue? = null
 ) : SessionBasedTowerLevel(session) {
-    override fun <T : ConeSymbol> processElementsByName(
+    override fun <T : FirBasedSymbol<*>> processElementsByName(
         token: TowerScopeLevel.Token<T>,
         name: Name,
         explicitReceiver: ExpressionReceiverValue?,
@@ -305,7 +302,7 @@ class ScopeTowerLevel(
  *  Handles only statics and top-levels, DOES NOT handle objects/companions members
  */
 class QualifiedReceiverTowerLevel(session: FirSession) : SessionBasedTowerLevel(session) {
-    override fun <T : ConeSymbol> processElementsByName(
+    override fun <T : FirBasedSymbol<*>> processElementsByName(
         token: TowerScopeLevel.Token<T>,
         name: Name,
         explicitReceiver: ExpressionReceiverValue?,
@@ -329,8 +326,8 @@ class QualifiedReceiverTowerLevel(session: FirSession) : SessionBasedTowerLevel(
             }
         } else {
             scope.processCallables(name, token.cast()) {
-                val fir = it.firUnsafe<FirCallableMemberDeclaration>()
+                val fir = it.fir
-                if (fir.isStatic || it.callableId.classId == null) {
+                if (fir is FirCallableMemberDeclaration<*> && fir.isStatic || it.callableId.classId == null) {
                     processor.consumeCandidate(it as T, null, null)
                 } else {
                     ProcessorAction.NEXT
@@ -341,7 +338,7 @@ class QualifiedReceiverTowerLevel(session: FirSession) : SessionBasedTowerLevel(
 
 }
 
-class QualifiedReceiverTowerDataConsumer<T : ConeSymbol>(
+class QualifiedReceiverTowerDataConsumer<T : FirBasedSymbol<*>>(
     val session: FirSession,
     val name: Name,
     val token: TowerScopeLevel.Token<T>,
@@ -599,7 +596,7 @@ class MultiplexerTowerDataConsumer(
 }
 
 
-class ExplicitReceiverTowerDataConsumer<T : ConeSymbol>(
+class ExplicitReceiverTowerDataConsumer<T : FirBasedSymbol<*>>(
     val session: FirSession,
     val name: Name,
     val token: TowerScopeLevel.Token<T>,
@@ -657,11 +654,11 @@ class ExplicitReceiverTowerDataConsumer<T : ConeSymbol>(
                             dispatchReceiverValue: ClassDispatchReceiverValue?,
                             implicitExtensionReceiverValue: ImplicitReceiverValue?
                         ): ProcessorAction {
-                            if (symbol is FirFunctionSymbol && symbol.callableId.packageName.startsWith(defaultPackage)) {
+                            if (symbol is FirNamedFunctionSymbol && symbol.callableId.packageName.startsWith(defaultPackage)) {
                                 val explicitReceiverType = explicitReceiver.type
                                 if (dispatchReceiverValue == null && explicitReceiverType is ConeClassType) {
                                     val declarationReceiverTypeRef =
-                                        (symbol as? FirCallableSymbol)?.fir?.receiverTypeRef as? FirResolvedTypeRef
+                                        (symbol as? FirCallableSymbol<*>)?.fir?.receiverTypeRef as? FirResolvedTypeRef
                                     val declarationReceiverType = declarationReceiverTypeRef?.type
                                     if (declarationReceiverType is ConeClassType) {
                                         if (!AbstractTypeChecker.isSubtypeOf(
@@ -699,7 +696,7 @@ class ExplicitReceiverTowerDataConsumer<T : ConeSymbol>(
 
 }
 
-class NoExplicitReceiverTowerDataConsumer<T : ConeSymbol>(
+class NoExplicitReceiverTowerDataConsumer<T : FirBasedSymbol<*>>(
     val session: FirSession,
     val name: Name,
     val token: TowerScopeLevel.Token<T>,
@@ -962,7 +959,7 @@ class InvokeCandidateCollector(
     }
 }
 
-fun FirCallableDeclaration.dispatchReceiverValue(session: FirSession): ClassDispatchReceiverValue? {
+fun FirCallableDeclaration<*>.dispatchReceiverValue(session: FirSession): ClassDispatchReceiverValue? {
     // TODO: this is not true at least for inner class constructors
     if (this is FirConstructor) return null
     val id = (this.symbol as ConeCallableSymbol).callableId.classId ?: return null

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

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.symbols.ConeSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.resolve.calls.components.PostponedArgumentsAnalyzer
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
@@ -28,7 +28,7 @@ class CandidateFactory(
     }
 
     fun createCandidate(
-        symbol: ConeSymbol,
+        symbol: FirBasedSymbol<*>,
         dispatchReceiverValue: ClassDispatchReceiverValue?,
         implicitExtensionReceiverValue: ImplicitReceiverValue?,
         explicitReceiverKind: ExplicitReceiverKind

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

@@ -6,12 +6,10 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.renderWithType
 import org.jetbrains.kotlin.fir.resolve.constructType
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.invoke
@@ -23,8 +21,8 @@ import org.jetbrains.kotlin.resolve.calls.inference.model.SimpleConstraintSystem
 
 internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() {
     override suspend fun check(candidate: Candidate, sink: CheckerSink, callInfo: CallInfo) {
-        val declaration = candidate.symbol.firUnsafe<FirDeclaration>()
+        val declaration = candidate.symbol.fir
-        if (declaration !is FirCallableMemberDeclaration || declaration.typeParameters.isEmpty()) {
+        if (declaration !is FirCallableMemberDeclaration<*> || declaration.typeParameters.isEmpty()) {
             candidate.substitutor = ConeSubstitutor.Empty
             return
         }
@@ -85,7 +83,7 @@ internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() {
 }
 
 fun createToFreshVariableSubstitutorAndAddInitialConstraints(
-    declaration: FirCallableMemberDeclaration,
+    declaration: FirCallableMemberDeclaration<*>,
     candidate: Candidate,
     csBuilder: ConstraintSystemOperation
 ): Pair<ConeSubstitutor, List<ConeTypeVariable>> {

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

@@ -5,11 +5,9 @@
 
 package org.jetbrains.kotlin.fir.resolve.calls
 
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirNamedFunction
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.coneTypeUnsafe
@@ -51,8 +49,7 @@ class ConeOverloadConflictResolver(
     }
 
     private fun createFlatSignature(call: Candidate): FlatSignature<Candidate> {
-        val declaration = call.symbol.firUnsafe<FirCallableDeclaration>()
+        return when (val declaration = call.symbol.fir) {
-        return when (declaration) {
             is FirNamedFunction -> createFlatSignature(call, declaration)
             is FirConstructor -> createFlatSignature(call, declaration)
             else -> error("Not supported: $declaration")

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

@@ -6,12 +6,9 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
 import org.jetbrains.kotlin.fir.resolve.FirProvider
-import org.jetbrains.kotlin.fir.resolve.transformers.firSafeNullable
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
@@ -24,7 +21,6 @@ import org.jetbrains.kotlin.load.java.JavaVisibilities
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind.*
-import java.lang.IllegalStateException
 
 
 abstract class ResolutionStage {
@@ -80,7 +76,7 @@ internal sealed class CheckReceivers : ResolutionStage() {
         }
 
         override fun Candidate.getReceiverValue(): ReceiverValue? {
-            val callableSymbol = symbol as? FirCallableSymbol ?: return null
+            val callableSymbol = symbol as? FirCallableSymbol<*> ?: return null
             val callable = callableSymbol.fir
             val type = (callable.receiverTypeRef as FirResolvedTypeRef?)?.type ?: return null
             return object : ReceiverValue {
@@ -136,8 +132,8 @@ internal sealed class CheckReceivers : ResolutionStage() {
 
 internal object MapArguments : ResolutionStage() {
     override suspend fun check(candidate: Candidate, sink: CheckerSink, callInfo: CallInfo) {
-        val symbol = candidate.symbol as? FirFunctionSymbol ?: return sink.reportApplicability(CandidateApplicability.HIDDEN)
+        val symbol = candidate.symbol as? FirFunctionSymbol<*> ?: return sink.reportApplicability(CandidateApplicability.HIDDEN)
-        val function = symbol.firUnsafe<FirFunction>()
+        val function = symbol.fir
         val processor = FirCallArgumentsProcessor(function, callInfo.arguments)
         val mappingResult = processor.process()
         candidate.argumentMapping = mappingResult.argumentMapping
@@ -190,8 +186,8 @@ internal object CheckVisibility : CheckerStage() {
 
     override suspend fun check(candidate: Candidate, sink: CheckerSink, callInfo: CallInfo) {
         val symbol = candidate.symbol
-        val declaration = symbol.firSafeNullable<FirMemberDeclaration>()
+        val declaration = symbol.fir
-        if (declaration != null && !declaration.visibility.isPublicAPI) {
+        if (declaration is FirMemberDeclaration && !declaration.visibility.isPublicAPI) {
             val visible = when (declaration.visibility) {
                 JavaVisibilities.PACKAGE_VISIBILITY ->
                     symbol.packageFqName() == callInfo.containingFile.packageFqName

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

@@ -11,10 +11,11 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirMemberPropertyImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
-import org.jetbrains.kotlin.fir.resolve.transformers.firSafeNullable
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.name.Name
 
@@ -33,10 +34,10 @@ class FirSyntheticPropertiesScope(
 
     private fun checkGetAndCreateSynthetic(
         name: Name,
-        symbol: ConeFunctionSymbol,
+        symbol: FirFunctionSymbol<*>,
-        processor: (ConeVariableSymbol) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> ProcessorAction
     ): ProcessorAction {
-        val fir = symbol.firSafeNullable<FirNamedFunction>() ?: return ProcessorAction.NEXT
+        val fir = symbol.fir as? FirNamedFunction ?: return ProcessorAction.NEXT
 
         if (fir.typeParameters.isNotEmpty()) return ProcessorAction.NEXT
         if (fir.valueParameters.isNotEmpty()) return ProcessorAction.NEXT
@@ -67,7 +68,7 @@ class FirSyntheticPropertiesScope(
         return processor(synthetic)
     }
 
-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
         if (name.isSpecial) return ProcessorAction.NEXT
         if (baseScope.processFunctionsByName(Name.guessByFirstCharacter("get${name.identifier.capitalize()}")) {
                 checkGetAndCreateSynthetic(name, it, processor)

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

@@ -9,8 +9,8 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -25,7 +25,7 @@ class FirCompositeSymbolProvider(val providers: List<FirSymbolProvider>) : FirSy
         return providers.firstNotNullResult { it.getClassUseSiteMemberScope(classId, useSiteSession, scopeSession) }
     }
 
-    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<ConeCallableSymbol> {
+    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> {
         return providers.flatMap { it.getTopLevelCallableSymbols(packageFqName, name) }
     }
 
@@ -35,7 +35,7 @@ class FirCompositeSymbolProvider(val providers: List<FirSymbolProvider>) : FirSy
         return providers.firstNotNullResult { it.getPackage(fqName) }
     }
 
-    override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? {
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? {
         return providers.firstNotNullResult { it.getClassLikeSymbolByFqName(classId) }
     }
 

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

@@ -13,8 +13,8 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.CallableId
-import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -28,7 +28,7 @@ class FirDependenciesSymbolProviderImpl(val session: FirSession) : AbstractFirSy
         }.toList()
     }
 
-    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<ConeCallableSymbol> {
+    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> {
         return topLevelCallableCache.lookupCacheOrCalculate(CallableId(packageFqName, null, name)) {
             dependencyProviders.flatMap { provider -> provider.getTopLevelCallableSymbols(packageFqName, name) }
         } ?: emptyList()
@@ -37,7 +37,7 @@ class FirDependenciesSymbolProviderImpl(val session: FirSession) : AbstractFirSy
     override fun getClassDeclaredMemberScope(classId: ClassId) =
         dependencyProviders.firstNotNullResult { it.getClassDeclaredMemberScope(classId) }
 
-    override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? {
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? {
         return classCache.lookupCacheOrCalculate(classId) {
             for (provider in dependencyProviders) {
                 provider.getClassLikeSymbolByFqName(classId)?.let {

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

@@ -20,12 +20,12 @@ import org.jetbrains.kotlin.fir.deserialization.FirBuiltinAnnotationDeserializer
 import org.jetbrains.kotlin.fir.deserialization.FirDeserializationContext
 import org.jetbrains.kotlin.fir.deserialization.deserializeClassToSymbol
 import org.jetbrains.kotlin.fir.resolve.*
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassDeclaredMemberScope
 import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
@@ -76,7 +76,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
 
         val lookup = mutableMapOf<ClassId, FirClassSymbol>()
 
-        fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? =
+        fun getClassLikeSymbolByFqName(classId: ClassId): FirClassSymbol? =
             findAndDeserializeClass(classId)
 
         private fun findAndDeserializeClass(
@@ -109,7 +109,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
             }
         }
 
-        fun getTopLevelCallableSymbols(name: Name): List<ConeCallableSymbol> {
+        fun getTopLevelCallableSymbols(name: Name): List<FirCallableSymbol<*>> {
             return packageProto.`package`.functionList.filter { nameResolver.getName(it.name) == name }.map {
                 memberDeserializer.loadFunction(it).symbol
             }
@@ -130,7 +130,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
         scopeSession: ScopeSession
     ): FirScope? {
         val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null
-        return symbol.firUnsafe<FirRegularClass>().buildDefaultUseSiteScope(useSiteSession, scopeSession)
+        return symbol.fir.buildDefaultUseSiteScope(useSiteSession, scopeSession)
     }
 
     override fun getPackage(fqName: FqName): FqName? {
@@ -152,9 +152,9 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
 
     private val allPackageFragments = loadBuiltIns().groupBy { it.fqName }
 
-    private val fictitiousFunctionSymbols = mutableMapOf<Int, ConeClassSymbol>()
+    private val fictitiousFunctionSymbols = mutableMapOf<Int, FirClassSymbol>()
 
-    override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? {
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassSymbol? {
         return allPackageFragments[classId.packageFqName]?.firstNotNullResult {
             it.getClassLikeSymbolByFqName(classId)
         } ?: with(classId) {
@@ -204,7 +204,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
                             FirMemberFunctionImpl(
                                 session,
                                 null,
-                                FirFunctionSymbol(CallableId(packageFqName, relativeClassName, name)),
+                                FirNamedFunctionSymbol(CallableId(packageFqName, relativeClassName, name)),
                                 name,
                                 Visibilities.PUBLIC,
                                 Modality.ABSTRACT,
@@ -251,7 +251,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
         }
     }
 
-    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<ConeCallableSymbol> {
+    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> {
         return allPackageFragments[packageFqName]?.flatMap {
             it.getTopLevelCallableSymbols(name)
         } ?: emptyList()
@@ -273,7 +273,7 @@ class FirLibrarySymbolProviderImpl(val session: FirSession) : FirSymbolProvider(
     }
 
     override fun getAllCallableNamesInClass(classId: ClassId): Set<Name> {
-        return getClassDeclarations(classId).filterIsInstance<FirCallableMemberDeclaration>().mapTo(mutableSetOf()) { it.name }
+        return getClassDeclarations(classId).filterIsInstance<FirCallableMemberDeclaration<*>>().mapTo(mutableSetOf()) { it.name }
     }
 
     private fun getClassDeclarations(classId: ClassId): List<FirDeclaration> {

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

@@ -15,6 +15,8 @@ import org.jetbrains.kotlin.fir.resolve.buildDefaultUseSiteScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassDeclaredMemberScope
 import org.jetbrains.kotlin.fir.symbols.*
+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.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
@@ -29,11 +31,11 @@ class FirProviderImpl(val session: FirSession) : FirProvider() {
         return state.callableContainerMap[symbol]
     }
 
-    override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? {
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? {
-        return (getFirClassifierByFqName(classId) as? FirSymbolOwner<*>)?.symbol as? ConeClassLikeSymbol
+        return getFirClassifierByFqName(classId)?.symbol
     }
 
-    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<ConeCallableSymbol> {
+    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> {
         return (state.callableMap[CallableId(packageFqName, null, name)] ?: emptyList())
     }
 
@@ -71,8 +73,10 @@ class FirProviderImpl(val session: FirSession) : FirProvider() {
                 state.classifierContainerFileMap[classId] = file
             }
 
-            override fun visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration) {
+            override fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(
-                val symbol = callableMemberDeclaration.symbol as ConeCallableSymbol
+                callableMemberDeclaration: FirCallableMemberDeclaration<F>
+            ) {
+                val symbol = callableMemberDeclaration.symbol
                 val callableId = symbol.callableId
                 state.callableMap.merge(callableId, listOf(symbol)) { a, b -> a + b }
                 state.callableContainerMap[symbol] = file
@@ -96,9 +100,9 @@ class FirProviderImpl(val session: FirSession) : FirProvider() {
 
     private class State {
         val fileMap = mutableMapOf<FqName, List<FirFile>>()
-        val classifierMap = mutableMapOf<ClassId, FirClassLikeDeclaration>()
+        val classifierMap = mutableMapOf<ClassId, FirClassLikeDeclaration<*>>()
         val classifierContainerFileMap = mutableMapOf<ClassId, FirFile>()
-        val callableMap = mutableMapOf<CallableId, List<ConeCallableSymbol>>()
+        val callableMap = mutableMapOf<CallableId, List<FirCallableSymbol<*>>>()
         val callableContainerMap = mutableMapOf<ConeCallableSymbol, FirFile>()
 
         fun setFrom(other: State) {
@@ -120,7 +124,7 @@ class FirProviderImpl(val session: FirSession) : FirProvider() {
         return state.fileMap[fqName].orEmpty()
     }
 
-    override fun getFirClassifierByFqName(fqName: ClassId): FirClassLikeDeclaration? {
+    override fun getFirClassifierByFqName(fqName: ClassId): FirClassLikeDeclaration<*>? {
         return state.classifierMap[fqName]
     }
 

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.*
 import org.jetbrains.kotlin.name.ClassId
@@ -29,13 +30,13 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver {
 
     private data class ClassIdInSession(val session: FirSession, val id: ClassId)
 
-    private val implicitBuiltinTypeSymbols = mutableMapOf<ClassIdInSession, ConeClassLikeSymbol>()
+    private val implicitBuiltinTypeSymbols = mutableMapOf<ClassIdInSession, FirClassLikeSymbol<*>>()
 
     // TODO: get rid of session used here, and may be also of the cache above (see KT-30275)
-    private fun resolveBuiltInQualified(id: ClassId, session: FirSession): ConeClassLikeSymbol {
+    private fun resolveBuiltInQualified(id: ClassId, session: FirSession): FirClassLikeSymbol<*> {
         val nameInSession = ClassIdInSession(session, id)
         return implicitBuiltinTypeSymbols.getOrPut(nameInSession) {
-            symbolProvider.getClassLikeSymbolByFqName(id) as ConeClassLikeSymbol
+            symbolProvider.getClassLikeSymbolByFqName(id)!!
         }
     }
 

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

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirTopLevelDeclaredMemberScope
 import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
 import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.*
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
@@ -205,8 +206,8 @@ open class FirBodyResolveTransformer(
                 FirErrorTypeRefImpl(session, access.psi, newCallee.errorReason)
             is FirResolvedCallableReference -> {
                 val symbol = newCallee.coneSymbol
-                if (symbol is ConeCallableSymbol) {
+                if (symbol is FirCallableSymbol<*>) {
-                    val returnType = jump.tryCalculateReturnType(symbol.firUnsafe())
+                    val returnType = jump.tryCalculateReturnType(symbol.fir)
                     if (access.safe && access.explicitReceiver!!.resultType.coneTypeUnsafe<ConeKotlinType>().isNullable) {
                         returnType.withReplacedConeType(
                             session,
@@ -215,11 +216,11 @@ open class FirBodyResolveTransformer(
                     } else {
                         returnType
                     }
-                } else if (symbol is ConeClassifierSymbol) {
+                } else if (symbol is ConeClassifierSymbol && symbol is FirBasedSymbol<*>) {
-                    val firUnsafe = symbol.firUnsafe<FirElement>()
+                    val fir = symbol.fir
                     // TODO: unhack
-                    if (firUnsafe is FirEnumEntry) {
+                    if (fir is FirEnumEntry) {
-                        (firUnsafe.superTypeRefs.firstOrNull() as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(
+                        (fir.superTypeRefs.firstOrNull() as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(
                             session,
                             null,
                             "no enum item supertype"
@@ -275,7 +276,7 @@ open class FirBodyResolveTransformer(
         val resultType = resolvedQualifier.resultType
         if (classId != null) {
             val classSymbol = symbolProvider.getClassLikeSymbolByFqName(classId)!!
-            val declaration = classSymbol.firUnsafe<FirClassLikeDeclaration>()
+            val declaration = classSymbol.fir
             if (declaration is FirClass) {
                 if (declaration.classKind == ClassKind.OBJECT) {
                     return resultType.resolvedTypeFromPrototype(
@@ -851,7 +852,7 @@ open class FirBodyResolveTransformer(
         val expectedType = data as FirTypeRef?
 
         val kind = constExpression.kind
-        if (expectedType == null || expectedType is FirImplicitTypeRef || expectedType == null ||
+        if (expectedType == null || expectedType is FirImplicitTypeRef ||
             kind == IrConstKind.Null || kind == IrConstKind.Boolean || kind == IrConstKind.Char
         ) {
             val symbol = when (kind) {
@@ -968,7 +969,7 @@ open class FirBodyResolveTransformer(
         }
     }
 
-    private fun storeVariableReturnType(variable: FirVariable) {
+    private fun storeVariableReturnType(variable: FirVariable<*>) {
         val initializer = variable.initializer
         if (variable.returnTypeRef is FirImplicitTypeRef) {
             when {
@@ -1021,8 +1022,8 @@ open class FirBodyResolveTransformer(
         }
     }
 
-    override fun transformVariable(variable: FirVariable, data: Any?): CompositeTransformResult<FirDeclaration> {
+    override fun <F : FirVariable<F>> transformVariable(variable: FirVariable<F>, data: Any?): CompositeTransformResult<FirDeclaration> {
-        val variable = super.transformVariable(variable, variable.returnTypeRef).single as FirVariable
+        val variable = super.transformVariable(variable, variable.returnTypeRef).single as FirVariable<*>
         storeVariableReturnType(variable)
         if (variable !is FirProperty) {
             localScopes.lastOrNull()?.storeDeclaration(variable)
@@ -1085,7 +1086,7 @@ open class FirBodyResolveTransformer(
                     val symbol = symbolProvider.getClassLikeSymbolByFqName(classId)!!
                     // TODO: Unify logic?
                     symbol.constructType(
-                        Array(symbol.firUnsafe<FirClassLikeDeclaration>().typeParameters.size) {
+                        Array(symbol.fir.typeParameters.size) {
                             ConeStarProjection
                         },
                         isNullable = false
@@ -1161,7 +1162,7 @@ class ReturnTypeCalculatorWithJump(val session: FirSession, val scopeSession: Sc
         val returnTypeRef = declaration.returnTypeRef
         if (returnTypeRef is FirResolvedTypeRef) return returnTypeRef
         cycleErrorType(declaration)?.let { return it }
-        require(declaration is FirCallableMemberDeclaration) { "${declaration::class}: ${declaration.render()}" }
+        require(declaration is FirCallableMemberDeclaration<*>) { "${declaration::class}: ${declaration.render()}" }
 
 
         val symbol = declaration.symbol as ConeCallableSymbol

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

@@ -68,7 +68,7 @@ class FirCallCompleterTransformer(
         val functionCall = functionCall.transformArguments(this, data) as FirFunctionCall
 
         val subCandidate = calleeReference.candidate
-        val declaration = subCandidate.symbol.firUnsafe<FirCallableMemberDeclaration>()
+        val declaration = subCandidate.symbol.firUnsafe<FirCallableMemberDeclaration<*>>()
         val newTypeParameters = declaration.typeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) }
             .map { subCandidate.substitutor.substituteOrSelf(it) }
             .map { finalSubstitutor.substituteOrSelf(it) }

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

@@ -33,7 +33,7 @@ class FirStatusResolveTransformer : FirAbstractTreeTransformer() {
         return when (this) {
             is FirEnumEntry -> Modality.FINAL
             is FirRegularClass -> if (classKind == ClassKind.INTERFACE) Modality.ABSTRACT else Modality.FINAL
-            is FirCallableMemberDeclaration -> {
+            is FirCallableMemberDeclaration<*> -> {
                 val containingClass = classes.lastOrNull()
                 when {
                     containingClass == null -> Modality.FINAL

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

@@ -59,7 +59,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer() {
         return property.compose()
     }
 
-    private fun resolveSupertypesOrExpansions(classLikeDeclaration: FirClassLikeDeclaration): FirDeclaration {
+    private fun resolveSupertypesOrExpansions(classLikeDeclaration: FirClassLikeDeclaration<*>): FirDeclaration {
         val classId = classLikeDeclaration.symbol.classId
 
         if (classId in fullyComputed) return classLikeDeclaration
@@ -76,7 +76,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer() {
         file: FirFile,
         private val currentlyComputing: MutableSet<ClassId>,
         private val fullyComputed: MutableSet<ClassId>,
-        private val knownFirClassLikeDeclaration: FirClassLikeDeclaration? = null
+        private val knownFirClassLikeDeclaration: FirClassLikeDeclaration<*>? = null
     ) : FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority = true) {
 
         lateinit var resultingClass: FirDeclaration
@@ -108,7 +108,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer() {
             return resolveNestedClassesSupertypes(transformedClass, data)
         }
 
-        private fun FirClassLikeDeclaration.matchesRequestedDeclaration(): Boolean {
+        private fun FirClassLikeDeclaration<*>.matchesRequestedDeclaration(): Boolean {
             if (knownFirClassLikeDeclaration != null) return knownFirClassLikeDeclaration == this
             return symbol.classId == requestedClassId
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/Scopes.kt

@@ -11,9 +11,9 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.buildUseSiteScope
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.impl.*
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.ConeAbbreviatedType
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
@@ -38,8 +38,7 @@ fun FirCompositeScope.addImportingScopes(file: FirFile, session: FirSession) {
 }
 
 private fun finalExpansionName(symbol: FirTypeAliasSymbol, session: FirSession): Name? {
-    val expandedType = symbol.fir.expandedTypeRef.coneTypeUnsafe<ConeClassLikeType>()
+    return when (val expandedType = symbol.fir.expandedTypeRef.coneTypeUnsafe<ConeClassLikeType>()) {
-    return when (expandedType) {
         is ConeAbbreviatedType ->
             expandedType.abbreviationLookupTag.toSymbol(session)?.safeAs<FirTypeAliasSymbol>()?.let {
                 finalExpansionName(it, session)
@@ -50,8 +49,8 @@ private fun finalExpansionName(symbol: FirTypeAliasSymbol, session: FirSession):
 }
 
 fun processConstructors(
-    matchedSymbol: ConeClassLikeSymbol?,
+    matchedSymbol: FirClassLikeSymbol<*>?,
-    processor: (ConeFunctionSymbol) -> ProcessorAction,
+    processor: (FirFunctionSymbol<*>) -> ProcessorAction,
     session: FirSession,
     scopeSession: ScopeSession,
     name: Name
@@ -61,13 +60,12 @@ fun processConstructors(
             val scope = when (matchedSymbol) {
                 is FirTypeAliasSymbol -> matchedSymbol.fir.buildUseSiteScope(session, scopeSession)
                 is FirClassSymbol -> matchedSymbol.fir.buildUseSiteScope(session, scopeSession)
-                else -> null
             }
 
 
             val constructorName = when (matchedSymbol) {
                 is FirTypeAliasSymbol -> finalExpansionName(matchedSymbol, session) ?: return ProcessorAction.NEXT
-                else -> name
+                is FirClassSymbol -> name
             }
 
             //TODO: why don't we use declared member scope at this point?

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

@@ -61,7 +61,7 @@ abstract class AbstractFirOverrideScope(val session: FirSession) : FirScope() {
     protected fun ConeCallableSymbol.isOverridden(seen: Set<ConeCallableSymbol>): ConeCallableSymbol? {
         if (overrides.containsKey(this)) return overrides[this]
 
-        fun similarFunctionsOrBothProperties(declaration: FirCallableDeclaration, self: FirCallableDeclaration): Boolean {
+        fun similarFunctionsOrBothProperties(declaration: FirCallableDeclaration<*>, self: FirCallableDeclaration<*>): Boolean {
             return when (declaration) {
                 is FirNamedFunction -> self is FirNamedFunction && isOverriddenFunCheck(declaration, self)
                 is FirConstructor -> false
@@ -75,9 +75,9 @@ abstract class AbstractFirOverrideScope(val session: FirSession) : FirScope() {
             }
         }
 
-        val self = (this as AbstractFirBasedSymbol<*>).fir as FirCallableMemberDeclaration
+        val self = (this as AbstractFirBasedSymbol<*>).fir as FirCallableMemberDeclaration<*>
         val overriding = seen.firstOrNull {
-            val member = (it as AbstractFirBasedSymbol<*>).fir as FirCallableMemberDeclaration
+            val member = (it as AbstractFirBasedSymbol<*>).fir as FirCallableMemberDeclaration<*>
             self.modality != Modality.FINAL
                     && similarFunctionsOrBothProperties(member, self)
         } // TODO: two or more overrides for one fun?

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

@@ -7,16 +7,17 @@ package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
-import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.declarations.expandedConeType
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.calls.TowerScopeLevel
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.processConstructors
 import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.addToStdlib.cast
@@ -32,9 +33,9 @@ abstract class FirAbstractImportingScope(session: FirSession, lookupInFir: Boole
 
 
         val symbol = provider.getClassLikeSymbolByFqName(classId) ?: error("No scope/symbol for $classId")
-        if (symbol is ConeTypeAliasSymbol) {
+        if (symbol is FirTypeAliasSymbol) {
-            val expansionSymbol = symbol.firUnsafe<FirTypeAlias>().expandedConeType?.lookupTag?.toSymbol(session)
+            val expansionSymbol = symbol.fir.expandedConeType?.lookupTag?.toSymbol(session)
-            if (expansionSymbol as? ConeClassLikeSymbol != null) {
+            if (expansionSymbol is ConeClassLikeSymbol) {
                 return getStaticsScope(expansionSymbol.classId)
             }
         }
@@ -42,11 +43,11 @@ abstract class FirAbstractImportingScope(session: FirSession, lookupInFir: Boole
         return null
     }
 
-    protected fun <T : ConeCallableSymbol> processCallables(
+    protected fun <T : FirCallableSymbol<*>> processCallables(
         import: FirResolvedImport,
         name: Name,
         token: TowerScopeLevel.Token<T>,
-        processor: (ConeCallableSymbol) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> ProcessorAction
     ): ProcessorAction {
         val callableId = CallableId(import.packageFqName, import.relativeClassName, name)
 
@@ -95,20 +96,20 @@ abstract class FirAbstractImportingScope(session: FirSession, lookupInFir: Boole
         return ProcessorAction.NEXT
     }
 
-    abstract fun <T : ConeCallableSymbol> processCallables(
+    abstract fun <T : FirCallableSymbol<*>> processCallables(
         name: Name,
         token: TowerScopeLevel.Token<T>,
-        processor: (ConeCallableSymbol) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> ProcessorAction
     ): ProcessorAction
 
-    final override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+    final override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
         return processCallables(
             name,
             TowerScopeLevel.Token.Functions
-        ) { if (it is ConeFunctionSymbol) processor(it) else ProcessorAction.NEXT }
+        ) { if (it is FirFunctionSymbol<*>) processor(it) else ProcessorAction.NEXT }
     }
 
-    final override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    final override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
         return processCallables(
             name,
             TowerScopeLevel.Token.Properties

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

@@ -10,9 +10,9 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.calls.TowerScopeLevel
 import org.jetbrains.kotlin.fir.scopes.FirPosition
-import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -41,10 +41,10 @@ abstract class FirAbstractSimpleImportingScope(session: FirSession) : FirAbstrac
         return true
     }
 
-    override fun <T : ConeCallableSymbol> processCallables(
+    override fun <T : FirCallableSymbol<*>> processCallables(
         name: Name,
         token: TowerScopeLevel.Token<T>,
-        processor: (ConeCallableSymbol) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> ProcessorAction
     ): ProcessorAction {
 
 

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

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.resolve.calls.TowerScopeLevel
 import org.jetbrains.kotlin.fir.scopes.FirPosition
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -41,10 +42,10 @@ abstract class FirAbstractStarImportingScope(
     }
 
 
-    override fun <T : ConeCallableSymbol> processCallables(
+    override fun <T : FirCallableSymbol<*>> processCallables(
         name: Name,
         token: TowerScopeLevel.Token<T>,
-        processor: (ConeCallableSymbol) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> ProcessorAction
     ): ProcessorAction {
         for (import in starImports) {
             if (processCallables(import, name, token, processor).stop()) {

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.name.Name
 
 class FirClassDeclaredMemberScopeProvider {
@@ -37,11 +38,11 @@ fun declaredMemberScope(klass: FirRegularClass): FirClassDeclaredMemberScope {
 }
 
 class FirClassDeclaredMemberScope(klass: FirRegularClass) : FirScope() {
-    private val callablesIndex: Map<Name, List<FirCallableSymbol>> = run {
+    private val callablesIndex: Map<Name, List<FirCallableSymbol<*>>> = run {
-        val result = mutableMapOf<Name, MutableList<FirCallableSymbol>>()
+        val result = mutableMapOf<Name, MutableList<FirCallableSymbol<*>>>()
         for (declaration in klass.declarations) {
             when (declaration) {
-                is FirCallableMemberDeclaration -> {
+                is FirCallableMemberDeclaration<*> -> {
                     val name = if (declaration is FirConstructor) klass.name else declaration.name
                     result.getOrPut(name) { mutableListOf() } += declaration.symbol
                 }
@@ -66,20 +67,20 @@ class FirClassDeclaredMemberScope(klass: FirRegularClass) : FirScope() {
         result
     }
 
-    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
         val symbols = callablesIndex[name] ?: emptyList()
         for (symbol in symbols) {
-            if (symbol is ConeFunctionSymbol && !processor(symbol)) {
+            if (symbol is FirFunctionSymbol<*> && !processor(symbol)) {
                 return STOP
             }
         }
         return NEXT
     }
 
-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
         val symbols = callablesIndex[name] ?: emptyList()
         for (symbol in symbols) {
-            if (symbol is ConePropertySymbol && !processor(symbol)) {
+            if (symbol is ConeVariableSymbol && !processor(symbol)) {
                 return STOP
             }
         }

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

@@ -6,8 +6,6 @@
 package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirConstructor
-import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirNamedFunction
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirMemberFunctionImpl
@@ -15,13 +13,14 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorWithJump
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
-import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.coneTypeUnsafe
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.name.Name
 
@@ -32,22 +31,22 @@ class FirClassSubstitutionScope(
     substitution: Map<ConeTypeParameterSymbol, ConeKotlinType>
 ) : FirScope() {
 
-    private val fakeOverrides = mutableMapOf<ConeCallableSymbol, ConeCallableSymbol>()
+    private val fakeOverrides = mutableMapOf<FirFunctionSymbol<*>, FirFunctionSymbol<*>>()
 
     private val substitutor = ConeSubstitutorByMap(substitution)
 
-    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
         useSiteScope.processFunctionsByName(name) process@{ original ->
 
             val function = fakeOverrides.getOrPut(original) { createFakeOverride(original) }
-            processor(function as ConeFunctionSymbol)
+            processor(function)
         }
 
 
         return super.processFunctionsByName(name, processor)
     }
 
-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
         return useSiteScope.processPropertiesByName(name, processor)
     }
 
@@ -57,11 +56,12 @@ class FirClassSubstitutionScope(
         return substitutor.substituteOrNull(this)
     }
 
-    private fun createFakeOverride(original: ConeFunctionSymbol): FirFunctionSymbol {
+    private fun createFakeOverride(original: FirFunctionSymbol<*>): FirFunctionSymbol<*> {
-
+        val member = when (original) {
-        val member = original.firUnsafe<FirFunction>()
+            is FirNamedFunctionSymbol -> original.fir
-        if (member is FirConstructor) return original as FirFunctionSymbol // TODO: substitution for constructors
+            is FirConstructorSymbol -> return original
-        member as FirNamedFunction
+            is FirAccessorSymbol -> throw AssertionError("Should not be here")
+        }
 
         val receiverType = member.receiverTypeRef?.coneTypeUnsafe<ConeKotlinType>()
         val newReceiverType = receiverType?.substitute()
@@ -73,19 +73,19 @@ class FirClassSubstitutionScope(
             it.returnTypeRef.coneTypeUnsafe<ConeKotlinType>().substitute()
         }
 
-        return createFakeOverride(session, member, original as FirFunctionSymbol, newReceiverType, newReturnType, newParameterTypes)
+        return createFakeOverride(session, member, original, newReceiverType, newReturnType, newParameterTypes)
     }
 
     companion object {
         fun createFakeOverride(
             session: FirSession,
             baseFunction: FirNamedFunction,
-            baseSymbol: FirFunctionSymbol,
+            baseSymbol: FirNamedFunctionSymbol,
             newReceiverType: ConeKotlinType? = null,
             newReturnType: ConeKotlinType? = null,
             newParameterTypes: List<ConeKotlinType?>? = null
-        ): FirFunctionSymbol {
+        ): FirNamedFunctionSymbol {
-            val symbol = FirFunctionSymbol(baseSymbol.callableId, true, baseSymbol)
+            val symbol = FirNamedFunctionSymbol(baseSymbol.callableId, true, baseSymbol)
             with(baseFunction) {
                 // TODO: consider using here some light-weight functions instead of pseudo-real FirMemberFunctionImpl
                 // As second alternative, we can invent some light-weight kind of FirRegularClass

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

@@ -12,6 +12,8 @@ import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP
 import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.name.Name
 
 class FirClassUseSiteScope(
@@ -20,7 +22,7 @@ class FirClassUseSiteScope(
     private val declaredMemberScope: FirScope
 ) : AbstractFirOverrideScope(session) {
 
-    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
         val seen = mutableSetOf<ConeCallableSymbol>()
         if (!declaredMemberScope.processFunctionsByName(name) {
                 seen += it
@@ -39,7 +41,7 @@ class FirClassUseSiteScope(
         }
     }
 
-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
         val seen = mutableSetOf<ConeCallableSymbol>()
         if (!declaredMemberScope.processPropertiesByName(name) {
                 seen += it

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

@@ -11,9 +11,9 @@ import org.jetbrains.kotlin.fir.scopes.FirTypeParameterScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP
-import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.name.Name
 
 class FirCompositeScope(
@@ -57,11 +57,11 @@ class FirCompositeScope(
         return NEXT
     }
 
-    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
         return processComposite(FirScope::processFunctionsByName, name, processor)
     }
 
-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
         return processComposite(FirScope::processPropertiesByName, name, processor)
     }
 

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

@@ -12,20 +12,21 @@ import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.expressions.FirVariable
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
-import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
 class FirLocalScope : FirScope() {
 
-    val properties = mutableMapOf<Name, ConeVariableSymbol>()
+    val properties = mutableMapOf<Name, FirVariableSymbol<*>>()
-    val functions = mutableMapOf<Name, ConeFunctionSymbol>()
+    val functions = mutableMapOf<Name, FirFunctionSymbol<*>>()
 
     fun storeDeclaration(declaration: FirNamedDeclaration) {
         when (declaration) {
-            is FirVariable -> properties[declaration.name] = declaration.symbol
+            is FirVariable<*> -> properties[declaration.name] = declaration.symbol
-            is FirNamedFunction -> functions[declaration.name] = declaration.symbol as FirFunctionSymbol
+            is FirNamedFunction -> functions[declaration.name] = declaration.symbol as FirNamedFunctionSymbol
         }
     }
 
@@ -33,7 +34,7 @@ class FirLocalScope : FirScope() {
         properties[FirBackingFieldReference.NAME] = property.backingFieldSymbol
     }
 
-    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
         val prop = functions[name]
         if (prop != null) {
             return processor(prop)
@@ -41,7 +42,7 @@ class FirLocalScope : FirScope() {
         return ProcessorAction.NEXT
     }
 
-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
         val prop = properties[name]
         if (prop != null) {
             return processor(prop)

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

@@ -8,9 +8,9 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
-import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.name.Name
 
 class FirSuperTypeScope(
@@ -18,7 +18,7 @@ class FirSuperTypeScope(
     val scopes: List<FirScope>
 ) : AbstractFirOverrideScope(session) {
 
-    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
         val accepted = HashSet<ConeFunctionSymbol>()
         val pending = mutableListOf<ConeFunctionSymbol>()
         for (scope in scopes) {
@@ -40,9 +40,9 @@ class FirSuperTypeScope(
         return super.processFunctionsByName(name, processor)
     }
 
-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
-        val accepted = HashSet<ConeCallableSymbol>()
+        val accepted = HashSet<FirCallableSymbol<*>>()
-        val pending = mutableListOf<ConeVariableSymbol>()
+        val pending = mutableListOf<FirCallableSymbol<*>>()
         for (scope in scopes) {
             if (scope.processPropertiesByName(name) {
                     if (it !in accepted && it.isOverridden(accepted) == null) {

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

@@ -12,9 +12,9 @@ import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP
 import org.jetbrains.kotlin.fir.scopes.processConstructors
-import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol
-import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -25,7 +25,7 @@ class FirTopLevelDeclaredMemberScope(
 ) : FirAbstractProviderBasedScope(session, lookupInFir) {
     private val packageFqName = file.packageFqName
 
-    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
         val matchedClass = provider.getClassLikeSymbolByFqName(ClassId(packageFqName, name))
 
         if (processConstructors(
@@ -40,14 +40,14 @@ class FirTopLevelDeclaredMemberScope(
         }
         val symbols = provider.getTopLevelCallableSymbols(packageFqName, name)
         for (symbol in symbols) {
-            if (symbol is ConeFunctionSymbol && !processor(symbol)) {
+            if (symbol is FirFunctionSymbol<*> && !processor(symbol)) {
                 return STOP
             }
         }
         return NEXT
     }
 
-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
         val symbols = provider.getTopLevelCallableSymbols(packageFqName, name)
         for (symbol in symbols) {
             if (symbol is ConePropertySymbol && !processor(symbol)) {

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

@@ -6,13 +6,14 @@
 package org.jetbrains.kotlin.fir.symbols
 
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.name.ClassId
 
 
-val FirSymbolProvider.Any: ConeClassLikeSymbol get() = this.getClassLikeSymbolByFqName(StandardClassIds.Any)!!
+val FirSymbolProvider.Any: FirClassLikeSymbol<*> get() = this.getClassLikeSymbolByFqName(StandardClassIds.Any)!!
-val FirSymbolProvider.Nothing: ConeClassLikeSymbol get() = this.getClassLikeSymbolByFqName(StandardClassIds.Nothing)!!
+val FirSymbolProvider.Nothing: FirClassLikeSymbol<*> get() = this.getClassLikeSymbolByFqName(StandardClassIds.Nothing)!!
 
 
-operator fun ClassId.invoke(symbolProvider: FirSymbolProvider): ConeClassLikeSymbol {
+operator fun ClassId.invoke(symbolProvider: FirSymbolProvider): FirClassLikeSymbol<*> {
     return symbolProvider.getClassLikeSymbolByFqName(this)!!
 }

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

@@ -277,8 +277,8 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext {
     }
 
     override fun TypeConstructorMarker.isCommonFinalClassConstructor(): Boolean {
-        val classSymbol = this as? ConeClassSymbol ?: return false
+        val classSymbol = this as? FirClassSymbol ?: return false
-        val fir = (classSymbol as FirClassSymbol).fir
+        val fir = classSymbol.fir
         return fir.modality == Modality.FINAL &&
                 fir.classKind != ClassKind.ENUM_ENTRY &&
                 fir.classKind != ClassKind.ANNOTATION_CLASS

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirLoadCompiledKotlin.kt

@@ -9,7 +9,6 @@ import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetModule
 import org.jetbrains.kotlin.name.ClassId
@@ -66,7 +65,7 @@ abstract class AbstractFirLoadCompiledKotlin : AbstractFirResolveWithSessionTest
 
         for (name in provider.getAllCallableNamesInPackage(packageFqName)) {
             for (symbol in provider.getTopLevelCallableSymbols(packageFqName, name)) {
-                (symbol as FirCallableSymbol).fir.accept(firRenderer)
+                symbol.fir.accept(firRenderer)
                 builder.appendln()
             }
         }

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/BuiltInsDeserializationForFirTestCase.kt

@@ -9,7 +9,6 @@ import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -42,7 +41,7 @@ class BuiltInsDeserializationForFirTestCase : AbstractFirResolveWithSessionTestC
 
         for (name in provider.getAllCallableNamesInPackage(packageFqName)) {
             for (symbol in provider.getTopLevelCallableSymbols(packageFqName, name)) {
-                (symbol as FirCallableSymbol).fir.accept(firRenderer)
+                symbol.fir.accept(firRenderer)
                 builder.appendln()
             }
         }

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt

@@ -34,7 +34,8 @@ import org.jetbrains.kotlin.fir.resolve.impl.FirCompositeSymbolProvider
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
 import org.jetbrains.kotlin.fir.service
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -190,8 +191,8 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
                             if (declaration in renderedDeclarations) continue
                             when (declaration) {
                                 is FirJavaConstructor -> enhancementScope.processFunctionsByName(javaClass.name) { symbol ->
-                                    val enhanced = (symbol as? FirFunctionSymbol)?.fir
+                                    val enhanced = symbol.fir
-                                    if (enhanced != null && enhanced !in renderedDeclarations) {
+                                    if (enhanced !in renderedDeclarations) {
                                         enhanced.accept(renderer, null)
                                         renderer.newLine()
                                         renderedDeclarations += enhanced
@@ -199,8 +200,8 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
                                     ProcessorAction.NEXT
                                 }
                                 is FirJavaMethod -> enhancementScope.processFunctionsByName(declaration.name) { symbol ->
-                                    val enhanced = (symbol as? FirFunctionSymbol)?.fir
+                                    val enhanced = symbol.fir
-                                    if (enhanced != null && enhanced !in renderedDeclarations) {
+                                    if (enhanced !in renderedDeclarations) {
                                         enhanced.accept(renderer, null)
                                         renderer.newLine()
                                         renderedDeclarations += enhanced
@@ -208,8 +209,8 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
                                     ProcessorAction.NEXT
                                 }
                                 is FirJavaField -> enhancementScope.processPropertiesByName(declaration.name) { symbol ->
-                                    val enhanced = (symbol as? FirPropertySymbol)?.fir
+                                    val enhanced = symbol.fir
-                                    if (enhanced != null && enhanced !in renderedDeclarations) {
+                                    if (enhanced !in renderedDeclarations) {
                                         enhanced.accept(renderer, null)
                                         renderer.newLine()
                                         renderedDeclarations += enhanced

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

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirUnitExpression
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef
@@ -146,7 +146,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         }
     }
 
-    override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) {
+    override fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>) {
         if (callableDeclaration is FirMemberDeclaration) {
             visitMemberDeclaration(callableDeclaration)
         } else {
@@ -178,7 +178,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
 
     private fun FirMemberDeclaration.modalityAsString(): String {
         return modality?.name?.toLowerCase() ?: run {
-            if (this is FirCallableMemberDeclaration && this.isOverride) {
+            if (this is FirCallableMemberDeclaration<*> && this.isOverride) {
                 "open?"
             } else {
                 "final?"
@@ -203,7 +203,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         if (memberDeclaration.isActual) {
             print("actual ")
         }
-        if (memberDeclaration is FirCallableMemberDeclaration) {
+        if (memberDeclaration is FirCallableMemberDeclaration<*>) {
             if (memberDeclaration.isOverride) {
                 print("override ")
             }
@@ -257,9 +257,9 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
 
     override fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration) {
         visitDeclaration(namedDeclaration)
-        if (namedDeclaration !is FirCallableDeclaration) { // Handled by visitCallableDeclaration
+        if (namedDeclaration !is FirCallableDeclaration<*>) { // Handled by visitCallableDeclaration
             print(" " + namedDeclaration.name)
-            if (namedDeclaration is FirClassLikeDeclaration) {
+            if (namedDeclaration is FirClassLikeDeclaration<*>) {
                 namedDeclaration.typeParameters.renderTypeParameters()
             }
         } else if (namedDeclaration is FirMemberDeclaration) {
@@ -278,7 +278,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
                 is FirNamedFunction -> "fun"
                 is FirProperty -> if (declaration.isVal) "val" else "var"
                 is FirField -> "field"
-                is FirVariable -> if (declaration.isVal) "lval" else "lvar"
+                is FirVariable<*> -> if (declaration.isVal) "lval" else "lvar"
                 else -> "unknown"
             }
         )
@@ -325,7 +325,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         anonymousObject.renderDeclarations()
     }
 
-    override fun visitVariable(variable: FirVariable) {
+    override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>) {
         visitCallableDeclaration(variable)
         variable.initializer?.let {
             print(" = ")
@@ -798,7 +798,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
 
     override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) {
         print("R|")
-        val isFakeOverride = (resolvedCallableReference.coneSymbol as? FirFunctionSymbol)?.isFakeOverride == true
+        val isFakeOverride = (resolvedCallableReference.coneSymbol as? FirNamedFunctionSymbol)?.isFakeOverride == true
 
         if (isFakeOverride) {
             print("FakeOverride<")
@@ -810,7 +810,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
             print(symbol.classId)
         if (isFakeOverride) {
             when (symbol) {
-                is FirFunctionSymbol -> {
+                is FirNamedFunctionSymbol -> {
                     print(": ")
                     symbol.fir.returnTypeRef.accept(this)
                 }

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

@@ -12,11 +12,11 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 // Good name needed (something with receiver, type parameters, return type, and name)
-interface FirCallableDeclaration :
+interface FirCallableDeclaration<F : FirCallableDeclaration<F>> :
     @VisitedSupertype FirDeclaration,
-    FirTypedDeclaration, FirSymbolOwner<FirCallableDeclaration> {
+    FirTypedDeclaration, FirSymbolOwner<F> {
 
-    override val symbol: FirCallableSymbol
+    override val symbol: FirCallableSymbol<F>
 
     val receiverTypeRef: FirTypeRef?
 

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

@@ -9,7 +9,8 @@ import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 
-interface FirCallableMemberDeclaration : @VisitedSupertype FirDeclaration, FirMemberDeclaration, FirCallableDeclaration {
+interface FirCallableMemberDeclaration<F : FirCallableMemberDeclaration<F>> :
+    @VisitedSupertype FirDeclaration, FirMemberDeclaration, FirCallableDeclaration<F> {
 
     val isOverride: Boolean get() = status.isOverride
 

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

@@ -7,14 +7,16 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
+import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
+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.visitors.FirVisitor
 
-interface FirClassLikeDeclaration : @VisitedSupertype FirMemberDeclaration, FirStatement {
+interface FirClassLikeDeclaration<F : FirClassLikeDeclaration<F>> :
-    val symbol: ConeClassLikeSymbol
+    @VisitedSupertype FirMemberDeclaration, FirStatement, FirSymbolOwner<F> {
+    override val symbol: FirClassLikeSymbol<F>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
         return super<FirMemberDeclaration>.accept(visitor, data)
@@ -25,7 +27,7 @@ interface FirClassLikeDeclaration : @VisitedSupertype FirMemberDeclaration, FirS
     }
 }
 
-fun ConeClassifierSymbol.toFirClassLike(): FirClassLikeDeclaration? =
+fun ConeClassifierSymbol.toFirClassLike(): FirClassLikeDeclaration<*>? =
     when (this) {
         is FirClassSymbol -> this.fir
         is FirTypeAliasSymbol -> this.fir

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

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 @BaseTransformedType
-interface FirConstructor : @VisitedSupertype FirFunction, FirCallableMemberDeclaration {
+interface FirConstructor : @VisitedSupertype FirMemberFunction<FirConstructor> {
 
     val isPrimary: Boolean get() = false
 

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

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirVariable
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 @BaseTransformedType
-interface FirField : @VisitedSupertype FirDeclaration, FirCallableMemberDeclaration, FirVariable {
+interface FirField : @VisitedSupertype FirDeclaration, FirCallableMemberDeclaration<FirField>, FirVariable<FirField> {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitField(this, data)
 

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.declarations
+
+import org.jetbrains.kotlin.fir.VisitedSupertype
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirMemberFunction<F : FirMemberFunction<F>> :
+    @VisitedSupertype FirFunction, FirCallableMemberDeclaration<F> {
+
+    override val symbol: FirFunctionSymbol<F>
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
+        return visitor.visitMemberFunction(this, data)
+    }
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        super<FirCallableMemberDeclaration>.acceptChildren(visitor, data)
+        for (parameter in valueParameters) {
+            parameter.accept(visitor, data)
+        }
+        body?.accept(visitor, data)
+    }
+}

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

@@ -7,12 +7,10 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.BaseTransformedType
 import org.jetbrains.kotlin.fir.VisitedSupertype
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 @BaseTransformedType
-interface FirNamedFunction : @VisitedSupertype FirFunction, FirCallableMemberDeclaration, FirMemberDeclaration {
+interface FirNamedFunction : @VisitedSupertype FirMemberFunction<FirNamedFunction>, FirMemberDeclaration {
     val isOperator: Boolean get() = status.isOperator
 
     val isInfix: Boolean get() = status.isInfix
@@ -29,12 +27,4 @@ interface FirNamedFunction : @VisitedSupertype FirFunction, FirCallableMemberDec
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitNamedFunction(this, data)
-
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        super<FirCallableMemberDeclaration>.acceptChildren(visitor, data)
-        for (parameter in valueParameters) {
-            parameter.accept(visitor, data)
-        }
-        body?.accept(visitor, data)
-    }
 }

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

@@ -14,7 +14,8 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 // May be should not inherit FirVariable
 @BaseTransformedType
-interface FirProperty : @VisitedSupertype FirDeclaration, FirCallableMemberDeclaration, FirVariable, FirMemberDeclaration {
+interface FirProperty :
+    @VisitedSupertype FirDeclaration, FirCallableMemberDeclaration<FirProperty>, FirVariable<FirProperty>, FirMemberDeclaration {
     val isConst: Boolean get() = status.isConst
 
     val isLateInit: Boolean get() = status.isLateInit

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

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.BaseTransformedType
 import org.jetbrains.kotlin.fir.VisitedSupertype
-import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
@@ -15,7 +14,7 @@ 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 FirRegularClass : FirClass, @VisitedSupertype FirClassLikeDeclaration, FirSymbolOwner<FirRegularClass> {
+interface FirRegularClass : FirClass, @VisitedSupertype FirClassLikeDeclaration<FirRegularClass> {
     val isInner: Boolean get() = status.isInner
 
     val isCompanion: Boolean get() = status.isCompanion

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

@@ -5,14 +5,13 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirTypeAlias : FirClassLikeDeclaration, FirSymbolOwner<FirTypeAlias> {
+interface FirTypeAlias : FirClassLikeDeclaration<FirTypeAlias> {
     fun replaceExpandTypeRef(typeRef: FirTypeRef): FirTypeAlias
 
     val expandedTypeRef: FirTypeRef

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

@@ -9,12 +9,11 @@ import org.jetbrains.kotlin.fir.BaseTransformedType
 import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirVariable
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 @BaseTransformedType
-interface FirValueParameter : @VisitedSupertype FirDeclaration, FirTypedDeclaration, FirNamedDeclaration, FirVariable {
+interface FirValueParameter : @VisitedSupertype FirDeclaration, FirTypedDeclaration, FirNamedDeclaration, FirVariable<FirValueParameter> {
     val isCrossinline: Boolean
 
     val isNoinline: Boolean
@@ -23,7 +22,7 @@ interface FirValueParameter : @VisitedSupertype FirDeclaration, FirTypedDeclarat
 
     val defaultValue: FirExpression?
 
-    override val symbol: FirVariableSymbol
+    override val symbol: FirVariableSymbol<FirValueParameter>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitValueParameter(this, data)

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

@@ -17,9 +17,9 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 
-abstract class FirAbstractCallableMember : FirAbstractMemberDeclaration, FirCallableMemberDeclaration {
+abstract class FirAbstractCallableMember<F : FirCallableMemberDeclaration<F>> :
+    FirAbstractMemberDeclaration, FirCallableMemberDeclaration<F> {
 
-//    final override val symbol: FirBasedSymbol<FirCallableDeclaration>
     final override var receiverTypeRef: FirTypeRef?
     final override var returnTypeRef: FirTypeRef
 

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

@@ -14,23 +14,23 @@ import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
-open class FirConstructorImpl : FirAbstractCallableMember, FirConstructor {
+open class FirConstructorImpl : FirAbstractCallableMember<FirConstructor>, FirConstructor {
 
-    override val symbol: FirFunctionSymbol
+    override val symbol: FirConstructorSymbol
 
     final override var delegatedConstructor: FirDelegatedConstructorCall? = null
 
     constructor(
         session: FirSession,
         psi: PsiElement?,
-        symbol: FirFunctionSymbol,
+        symbol: FirConstructorSymbol,
         visibility: Visibility,
         isExpect: Boolean,
         isActual: Boolean,
@@ -48,7 +48,7 @@ open class FirConstructorImpl : FirAbstractCallableMember, FirConstructor {
     constructor(
         session: FirSession,
         psi: PsiElement?,
-        symbol: FirFunctionSymbol,
+        symbol: FirConstructorSymbol,
         receiverTypeRef: FirTypeRef?,
         returnTypeRef: FirTypeRef
     ) : super(session, psi, NAME, receiverTypeRef, returnTypeRef) {

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

@@ -20,7 +20,7 @@ class FirDefaultSetterValueParameter(
     session: FirSession,
     psi: PsiElement?,
     override var returnTypeRef: FirTypeRef,
-    override val symbol: FirVariableSymbol = FirVariableSymbol(name)
+    override val symbol: FirVariableSymbol<FirValueParameter> = FirVariableSymbol(name)
 ) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirValueParameter {
 
     init {

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

@@ -12,22 +12,23 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirBlock
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
-open class FirMemberFunctionImpl : FirAbstractCallableMember, FirNamedFunction, FirModifiableFunction {
+open class FirMemberFunctionImpl : FirAbstractCallableMember<FirNamedFunction>, FirNamedFunction, FirModifiableFunction {
 
-    override val symbol: FirCallableSymbol
+    // NB: FirAccessorSymbol can be here
+    override val symbol: FirFunctionSymbol<FirNamedFunction>
 
     constructor(
         session: FirSession,
         psi: PsiElement?,
-        symbol: FirCallableSymbol,
+        symbol: FirFunctionSymbol<FirNamedFunction>,
         name: Name,
         receiverTypeRef: FirTypeRef?,
         returnTypeRef: FirTypeRef
@@ -39,7 +40,7 @@ open class FirMemberFunctionImpl : FirAbstractCallableMember, FirNamedFunction,
     constructor(
         session: FirSession,
         psi: PsiElement?,
-        symbol: FirFunctionSymbol,
+        symbol: FirNamedFunctionSymbol,
         name: Name,
         visibility: Visibility,
         modality: Modality?,

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

@@ -40,7 +40,7 @@ class FirMemberPropertyImpl(
     override var getter: FirPropertyAccessor,
     override var setter: FirPropertyAccessor?,
     override var delegate: FirExpression?
-) : FirAbstractCallableMember(
+) : FirAbstractCallableMember<FirProperty>(
     session, psi, name, visibility, modality, isExpect, isActual, isOverride, receiverTypeRef, returnTypeRef
 ), FirProperty {
     override val backingFieldSymbol = FirBackingFieldSymbol(symbol.callableId)

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

@@ -9,13 +9,13 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 
 class FirPrimaryConstructorImpl(
     session: FirSession,
     psi: PsiElement?,
-    symbol: FirFunctionSymbol,
+    symbol: FirConstructorSymbol,
     visibility: Visibility,
     isExpect: Boolean,
     isActual: Boolean,

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

@@ -25,7 +25,7 @@ open class FirValueParameterImpl(
     override val isCrossinline: Boolean,
     override val isNoinline: Boolean,
     override val isVararg: Boolean,
-    override val symbol: FirVariableSymbol = FirVariableSymbol(name)
+    override val symbol: FirVariableSymbol<FirValueParameter> = FirVariableSymbol(name)
 ) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirValueParameter {
 
     init {

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

@@ -8,10 +8,8 @@ package org.jetbrains.kotlin.fir.declarations.impl
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirVariable
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -25,9 +23,9 @@ class FirVariableImpl(
     override var returnTypeRef: FirTypeRef,
     override val isVar: Boolean,
     override var initializer: FirExpression?,
-    override val symbol: FirVariableSymbol = FirVariableSymbol(name),
+    override val symbol: FirVariableSymbol<FirVariableImpl> = FirVariableSymbol(name),
     override var delegate: FirExpression? = null
-) : FirAbstractNamedAnnotatedDeclaration(session, psiElement, name), FirVariable {
+) : FirAbstractNamedAnnotatedDeclaration(session, psiElement, name), FirVariable<FirVariableImpl> {
 
     init {
         symbol.bind(this)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirVariable.kt

@@ -10,7 +10,8 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirVariable : @VisitedSupertype FirDeclaration, FirTypedDeclaration, FirCallableDeclaration, FirNamedDeclaration, FirStatement {
+interface FirVariable<F : FirVariable<F>> :
+    @VisitedSupertype FirDeclaration, FirTypedDeclaration, FirCallableDeclaration<F>, FirNamedDeclaration, FirStatement {
     val isVar: Boolean
 
     val isVal: Boolean
@@ -20,7 +21,7 @@ interface FirVariable : @VisitedSupertype FirDeclaration, FirTypedDeclaration, F
 
     val delegate: FirExpression?
 
-    override val symbol: FirVariableSymbol
+    override val symbol: FirVariableSymbol<F>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitVariable(this, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenExpression.kt

@@ -17,7 +17,7 @@ abstract class FirWhenExpression(
     abstract val subject: FirExpression?
 
     // when (val subjectVariable = subject()) { ... }
-    abstract val subjectVariable: FirVariable?
+    abstract val subjectVariable: FirVariable<*>?
 
     abstract val branches: List<FirWhenBranch>
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirWhenExpressionImpl.kt

@@ -17,7 +17,7 @@ class FirWhenExpressionImpl(
     session: FirSession,
     psiElement: PsiElement?,
     override var subject: FirExpression? = null,
-    override var subjectVariable: FirVariable? = null
+    override var subjectVariable: FirVariable<*>? = null
 ) : FirWhenExpression(session, psiElement) {
     override val branches = mutableListOf<FirWhenBranch>()
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirPropertyFromParameterCallableReference.kt

@@ -16,5 +16,5 @@ class FirPropertyFromParameterCallableReference(
     session: FirSession,
     psi: PsiElement?,
     override val name: Name,
-    override val coneSymbol: FirVariableSymbol
+    override val coneSymbol: FirVariableSymbol<*>
 ) : FirAbstractElement(session, psi), FirResolvedCallableReference

compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirScope.kt

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.fir.scopes
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.NEXT
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.STOP
 import org.jetbrains.kotlin.fir.symbols.ConeClassifierSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.name.Name
 
 abstract class FirScope {
@@ -25,12 +25,13 @@ abstract class FirScope {
 
     open fun processFunctionsByName(
         name: Name,
-        processor: (ConeFunctionSymbol) -> ProcessorAction
+        processor: (FirFunctionSymbol<*>) -> ProcessorAction
     ): ProcessorAction = NEXT
 
     open fun processPropertiesByName(
         name: Name,
-        processor: (ConeVariableSymbol) -> ProcessorAction
+        // NB: it'd be great to write FirVariableSymbol<*> here, but there is FirAccessorSymbol :(
+        processor: (FirCallableSymbol<*>) -> ProcessorAction
     ): ProcessorAction = NEXT
 }
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/AbstractFirBasedSymbol.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.symbols
 
-import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 
-abstract class AbstractFirBasedSymbol<E> : FirBasedSymbol<E> where E : FirElement, E : FirSymbolOwner<E> {
+abstract class AbstractFirBasedSymbol<E> : FirBasedSymbol<E> where E : FirDeclaration, E : FirSymbolOwner<E> {
 
     override lateinit var fir: E
 

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

@@ -1,14 +0,0 @@
-/*
- * 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.CallableId
-import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol
-
-class FirAccessorSymbol(
-    override val callableId: CallableId,
-    val accessorId: CallableId
-) : ConePropertySymbol, FirCallableSymbol()

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

@@ -9,4 +9,4 @@ import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
 
-abstract class FirCallableSymbol : ConeCallableSymbol, AbstractFirBasedSymbol<FirCallableDeclaration>()
+abstract class FirCallableSymbol<D : FirCallableDeclaration<D>> : ConeCallableSymbol, AbstractFirBasedSymbol<D>()

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

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2018 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.declarations.FirClassLikeDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
+import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.name.ClassId
+
+sealed class FirClassLikeSymbol<D : FirClassLikeDeclaration<D>>(
+    override val classId: ClassId
+) : ConeClassLikeSymbol, AbstractFirBasedSymbol<D>() {
+    override fun equals(other: Any?): Boolean =
+        other is FirClassLikeSymbol<*> && fir == other.fir
+
+    override fun hashCode(): Int = fir.hashCode()
+}
+
+class FirClassSymbol(classId: ClassId) : FirClassLikeSymbol<FirRegularClass>(classId), ConeClassSymbol {
+    override fun toLookupTag(): ConeClassLikeLookupTag = ConeClassLikeLookupTagImpl(classId)
+}
+
+class FirTypeAliasSymbol(override val classId: ClassId) : FirClassLikeSymbol<FirTypeAlias>(classId), ConeTypeAliasSymbol {
+    override fun toLookupTag(): TypeAliasLookupTagImpl = TypeAliasLookupTagImpl(classId)
+}
+
+class TypeAliasLookupTagImpl(
+    override val classId: ClassId
+) : ConeTypeAliasLookupTag()

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

@@ -1,22 +0,0 @@
-/*
- * Copyright 2010-2018 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.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTagImpl
-import org.jetbrains.kotlin.fir.symbols.ConeClassSymbol
-import org.jetbrains.kotlin.name.ClassId
-
-class FirClassSymbol(override val classId: ClassId) : ConeClassSymbol, AbstractFirBasedSymbol<FirRegularClass>() {
-    override fun toLookupTag(): ConeClassLikeLookupTag = ConeClassLikeLookupTagImpl(classId)
-
-    override fun equals(other: Any?): Boolean =
-        other is FirClassSymbol && fir == other.fir
-
-    override fun hashCode(): Int = fir.hashCode()
-}

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

@@ -1,8 +0,0 @@
-/*
- * 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
-
-typealias FirFieldSymbol = FirPropertySymbol

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

@@ -5,16 +5,31 @@
 
 package org.jetbrains.kotlin.fir.symbols.impl
 
+import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 
-class FirFunctionSymbol(
+sealed class FirFunctionSymbol<D : FirMemberFunction<D>>(
-    override val callableId: CallableId,
+    override val callableId: CallableId
-    val isFakeOverride: Boolean = false,
+) : ConeFunctionSymbol, FirCallableSymbol<D>() {
-    // Actual for fake override only
-    val overriddenSymbol: FirFunctionSymbol? = null
-) : ConeFunctionSymbol, FirCallableSymbol() {
     override val parameters: List<ConeKotlinType>
         get() = emptyList()
 }
+
+class FirNamedFunctionSymbol(
+    callableId: CallableId,
+    val isFakeOverride: Boolean = false,
+    // Actual for fake override only
+    val overriddenSymbol: FirNamedFunctionSymbol? = null
+) : FirFunctionSymbol<FirNamedFunction>(callableId)
+
+class FirConstructorSymbol(
+    callableId: CallableId
+) : FirFunctionSymbol<FirConstructor>(callableId)
+
+class FirAccessorSymbol(
+    callableId: CallableId,
+    val accessorId: CallableId
+) : ConePropertySymbol, FirFunctionSymbol<FirNamedFunction>(callableId)

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

@@ -12,22 +12,3 @@ import org.jetbrains.kotlin.fir.symbols.ConeTypeAliasLookupTag
 import org.jetbrains.kotlin.fir.symbols.ConeTypeAliasSymbol
 import org.jetbrains.kotlin.name.ClassId
 
-class FirTypeAliasSymbol(
-    override val classId: ClassId
-) : ConeTypeAliasSymbol, AbstractFirBasedSymbol<FirTypeAlias>() {
-    override fun toLookupTag(): ConeClassLikeLookupTag = TypeAliasLookupTagImpl(classId)
-
-    override fun equals(other: Any?): Boolean =
-        other is FirTypeAliasSymbol && classId == other.classId && fir == other.fir
-
-    override fun hashCode(): Int {
-        var result = 31
-        result = result * 19 + classId.hashCode()
-        result = result * 19 + fir.hashCode()
-        return result
-    }
-}
-
-class TypeAliasLookupTagImpl(
-    override val classId: ClassId
-) : ConeTypeAliasLookupTag()

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

@@ -5,17 +5,22 @@
 
 package org.jetbrains.kotlin.fir.symbols.impl
 
+import org.jetbrains.kotlin.fir.declarations.FirField
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.expressions.FirVariable
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol
 import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol
 import org.jetbrains.kotlin.name.Name
 
-open class FirPropertySymbol(callableId: CallableId) : FirVariableSymbol(callableId), ConePropertySymbol
+open class FirVariableSymbol<D : FirVariable<D>>(override val callableId: CallableId) : ConeVariableSymbol, FirCallableSymbol<D>() {
-
-class FirBackingFieldSymbol(callableId: CallableId) : FirVariableSymbol(callableId)
-
-open class FirVariableSymbol(override val callableId: CallableId) : ConeVariableSymbol, FirCallableSymbol() {
 
     @Deprecated("TODO: Better solution for local vars?")
     constructor(name: Name) : this(CallableId(name))  // TODO?
 }
+
+open class FirPropertySymbol(callableId: CallableId) : ConePropertySymbol, FirVariableSymbol<FirProperty>(callableId)
+
+class FirBackingFieldSymbol(callableId: CallableId) : FirVariableSymbol<FirProperty>(callableId)
+
+class FirFieldSymbol(callableId: CallableId) : FirVariableSymbol<FirField>(callableId)

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt

@@ -24,11 +24,11 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformElement(declaration, data)
     }
 
-    open fun transformCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
+    open fun <F : FirCallableDeclaration<F>> transformCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
         return transformDeclaration(callableDeclaration, data)
     }
 
-    open fun transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
+    open fun <F : FirCallableMemberDeclaration<F>> transformCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
         return transformDeclaration(callableMemberDeclaration, data)
     }
 
@@ -48,18 +48,22 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformFunction(anonymousFunction, data)
     }
 
+    open fun <F : FirMemberFunction<F>> transformMemberFunction(memberFunction: FirMemberFunction<F>, data: D): CompositeTransformResult<FirDeclaration> {
+        return transformFunction(memberFunction, data)
+    }
+
     open fun transformConstructor(constructor: FirConstructor, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformFunction(constructor, data)
+        return transformMemberFunction(constructor, data)
+    }
+
+    open fun transformNamedFunction(namedFunction: FirNamedFunction, data: D): CompositeTransformResult<FirDeclaration> {
+        return transformMemberFunction(namedFunction, data)
     }
 
     open fun transformModifiableFunction(modifiableFunction: FirModifiableFunction, data: D): CompositeTransformResult<FirDeclaration> {
         return transformFunction(modifiableFunction, data)
     }
 
-    open fun transformNamedFunction(namedFunction: FirNamedFunction, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformFunction(namedFunction, data)
-    }
-
     open fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): CompositeTransformResult<FirDeclaration> {
         return transformFunction(propertyAccessor, data)
     }
@@ -84,7 +88,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformNamedDeclaration(memberDeclaration, data)
     }
 
-    open fun transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
+    open fun <F : FirClassLikeDeclaration<F>> transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirDeclaration> {
         return transformMemberDeclaration(classLikeDeclaration, data)
     }
 
@@ -116,7 +120,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformDeclaration(valueParameter, data)
     }
 
-    open fun transformVariable(variable: FirVariable, data: D): CompositeTransformResult<FirDeclaration> {
+    open fun <F : FirVariable<F>> transformVariable(variable: FirVariable<F>, data: D): CompositeTransformResult<FirDeclaration> {
         return transformDeclaration(variable, data)
     }
 
@@ -488,11 +492,11 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformCallWithArgumentList(callWithArgumentList, data)
     }
 
-    final override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): CompositeTransformResult<FirElement> {
+    final override fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: D): CompositeTransformResult<FirElement> {
         return transformCallableDeclaration(callableDeclaration, data)
     }
 
-    final override fun visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): CompositeTransformResult<FirElement> {
+    final override fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: D): CompositeTransformResult<FirElement> {
         return transformCallableMemberDeclaration(callableMemberDeclaration, data)
     }
 
@@ -508,7 +512,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformClass(klass, data)
     }
 
-    final override fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): CompositeTransformResult<FirElement> {
+    final override fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): CompositeTransformResult<FirElement> {
         return transformClassLikeDeclaration(classLikeDeclaration, data)
     }
 
@@ -648,6 +652,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformMemberDeclaration(memberDeclaration, data)
     }
 
+    final override fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>, data: D): CompositeTransformResult<FirElement> {
+        return transformMemberFunction(memberFunction, data)
+    }
+
     final override fun visitModifiableClass(modifiableClass: FirModifiableClass, data: D): CompositeTransformResult<FirElement> {
         return transformModifiableClass(modifiableClass, data)
     }
@@ -828,7 +836,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformValueParameter(valueParameter, data)
     }
 
-    final override fun visitVariable(variable: FirVariable, data: D): CompositeTransformResult<FirElement> {
+    final override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>, data: D): CompositeTransformResult<FirElement> {
         return transformVariable(variable, data)
     }
 

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt

@@ -24,11 +24,11 @@ abstract class FirVisitor<out R, in D> {
         return visitElement(declaration, data)
     }
 
-    open fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): R {
+    open fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: D): R {
         return visitDeclaration(callableDeclaration, data)
     }
 
-    open fun visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: D): R {
+    open fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: D): R {
         return visitDeclaration(callableMemberDeclaration, data)
     }
 
@@ -48,18 +48,22 @@ abstract class FirVisitor<out R, in D> {
         return visitFunction(anonymousFunction, data)
     }
 
+    open fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>, data: D): R {
+        return visitFunction(memberFunction, data)
+    }
+
     open fun visitConstructor(constructor: FirConstructor, data: D): R {
-        return visitFunction(constructor, data)
+        return visitMemberFunction(constructor, data)
+    }
+
+    open fun visitNamedFunction(namedFunction: FirNamedFunction, data: D): R {
+        return visitMemberFunction(namedFunction, data)
     }
 
     open fun visitModifiableFunction(modifiableFunction: FirModifiableFunction, data: D): R {
         return visitFunction(modifiableFunction, data)
     }
 
-    open fun visitNamedFunction(namedFunction: FirNamedFunction, data: D): R {
-        return visitFunction(namedFunction, data)
-    }
-
     open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): R {
         return visitFunction(propertyAccessor, data)
     }
@@ -84,7 +88,7 @@ abstract class FirVisitor<out R, in D> {
         return visitNamedDeclaration(memberDeclaration, data)
     }
 
-    open fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: D): R {
+    open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: D): R {
         return visitMemberDeclaration(classLikeDeclaration, data)
     }
 
@@ -116,7 +120,7 @@ abstract class FirVisitor<out R, in D> {
         return visitDeclaration(valueParameter, data)
     }
 
-    open fun visitVariable(variable: FirVariable, data: D): R {
+    open fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>, data: D): R {
         return visitDeclaration(variable, data)
     }
 

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt

@@ -24,11 +24,11 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(declaration, null)
     }
 
-    open fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) {
+    open fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>) {
         visitDeclaration(callableDeclaration, null)
     }
 
-    open fun visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration) {
+    open fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>) {
         visitDeclaration(callableMemberDeclaration, null)
     }
 
@@ -48,18 +48,22 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitFunction(anonymousFunction, null)
     }
 
+    open fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>) {
+        visitFunction(memberFunction, null)
+    }
+
     open fun visitConstructor(constructor: FirConstructor) {
-        visitFunction(constructor, null)
+        visitMemberFunction(constructor, null)
+    }
+
+    open fun visitNamedFunction(namedFunction: FirNamedFunction) {
+        visitMemberFunction(namedFunction, null)
     }
 
     open fun visitModifiableFunction(modifiableFunction: FirModifiableFunction) {
         visitFunction(modifiableFunction, null)
     }
 
-    open fun visitNamedFunction(namedFunction: FirNamedFunction) {
-        visitFunction(namedFunction, null)
-    }
-
     open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) {
         visitFunction(propertyAccessor, null)
     }
@@ -84,7 +88,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitNamedDeclaration(memberDeclaration, null)
     }
 
-    open fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration) {
+    open fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>) {
         visitMemberDeclaration(classLikeDeclaration, null)
     }
 
@@ -116,7 +120,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitDeclaration(valueParameter, null)
     }
 
-    open fun visitVariable(variable: FirVariable) {
+    open fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>) {
         visitDeclaration(variable, null)
     }
 
@@ -488,11 +492,11 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitCallWithArgumentList(callWithArgumentList)
     }
 
-    final override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: Nothing?) {
+    final override fun <F : FirCallableDeclaration<F>> visitCallableDeclaration(callableDeclaration: FirCallableDeclaration<F>, data: Nothing?) {
         visitCallableDeclaration(callableDeclaration)
     }
 
-    final override fun visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration, data: Nothing?) {
+    final override fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(callableMemberDeclaration: FirCallableMemberDeclaration<F>, data: Nothing?) {
         visitCallableMemberDeclaration(callableMemberDeclaration)
     }
 
@@ -508,7 +512,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitClass(klass)
     }
 
-    final override fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: Nothing?) {
+    final override fun <F : FirClassLikeDeclaration<F>> visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration<F>, data: Nothing?) {
         visitClassLikeDeclaration(classLikeDeclaration)
     }
 
@@ -648,6 +652,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitMemberDeclaration(memberDeclaration)
     }
 
+    final override fun <F : FirMemberFunction<F>> visitMemberFunction(memberFunction: FirMemberFunction<F>, data: Nothing?) {
+        visitMemberFunction(memberFunction)
+    }
+
     final override fun visitModifiableClass(modifiableClass: FirModifiableClass, data: Nothing?) {
         visitModifiableClass(modifiableClass)
     }
@@ -828,7 +836,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitValueParameter(valueParameter)
     }
 
-    final override fun visitVariable(variable: FirVariable, data: Nothing?) {
+    final override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>, data: Nothing?) {
         visitVariable(variable)
     }
 

compiler/testData/ir/irText/expressions/javaSyntheticPropertyAccess.fir.txt

@@ -2,10 +2,12 @@ FILE fqName:<root> fileName:/javaSyntheticPropertyAccess.kt
   FUN name:test visibility:public modality:FINAL <> (j:<root>.J) returnType:kotlin.Unit 
     VALUE_PARAMETER name:j index:0 type:<root>.J 
     BLOCK_BODY
-      ERROR_CALL 'Unresolved reference: R|/J.foo|' type=kotlin.Int
+      CALL 'public open fun getFoo (): kotlin.Int declared in <root>.J' type=kotlin.Int origin=null
+        $this: GET_VAR 'j: <root>.J declared in <root>.test' type=<root>.J origin=null
       ERROR_CALL 'Unresolved reference: R|/J.foo|' type=IrErrorType
       VAR name:<unary> type:kotlin.Int [val] 
-        ERROR_CALL 'Unresolved reference: R|/J.foo|' type=kotlin.Int
+        CALL 'public open fun getFoo (): kotlin.Int declared in <root>.J' type=kotlin.Int origin=null
+          $this: GET_VAR 'j: <root>.J declared in <root>.test' type=<root>.J origin=null
       ERROR_CALL 'Unresolved reference: R|/J.foo|' type=IrErrorType
       GET_VAR 'val <unary>: kotlin.Int [val] declared in <root>.test' type=kotlin.Int origin=null
       ERROR_CALL 'Unresolved reference: R|/J.foo|' type=IrErrorType

compiler/testData/ir/irText/stubs/javaSyntheticProperty.fir.txt

@@ -2,7 +2,8 @@ FILE fqName:<root> fileName:/javaSyntheticProperty.kt
   PROPERTY name:test visibility:public modality:FINAL [val] 
     FIELD PROPERTY_BACKING_FIELD name:test type:kotlin.String? visibility:public [final,static]
       EXPRESSION_BODY
-        ERROR_CALL 'Unresolved reference: R|/J.foo|' type=kotlin.String?
+        CALL 'public open fun getFoo (): kotlin.String? declared in <root>.J' type=kotlin.String? origin=null
+          $this: CONSTRUCTOR_CALL 'public constructor <init> () declared in <root>.J' type=<root>.J origin=null
     FUN DEFAULT_PROPERTY_ACCESSOR name:<get-test> visibility:public modality:FINAL <> () returnType:kotlin.String?
       correspondingProperty: PROPERTY name:test visibility:public modality:FINAL [val] 
       BLOCK_BODY

idea/src/org/jetbrains/kotlin/idea/fir/IdeFirDependenciesSymbolProvider.kt

@@ -17,8 +17,8 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.service
-import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.caches.project.getModuleInfo
 import org.jetbrains.kotlin.idea.stubindex.KotlinFullClassNameIndex
@@ -43,7 +43,7 @@ class IdeFirDependenciesSymbolProvider(
     private val javaSymbolProvider by lazy { JavaSymbolProvider(sessionProvider.getSession(moduleInfo)!!, project, depScope) }
 
 
-    private fun buildKotlinClassOnRequest(file: KtFile, classId: ClassId, session: FirSession): ConeClassLikeSymbol? {
+    private fun buildKotlinClassOnRequest(file: KtFile, classId: ClassId, session: FirSession): FirClassLikeSymbol<*>? {
         val impl = FirProvider.getInstance(session) as FirProviderImpl
         val classifier = impl.getClassLikeSymbolByFqName(classId)
         if (classifier != null) {
@@ -69,7 +69,7 @@ class IdeFirDependenciesSymbolProvider(
         TODO("not implemented")
     }
 
-    private fun tryKotlin(classId: ClassId): ConeClassLikeSymbol? {
+    private fun tryKotlin(classId: ClassId): FirClassLikeSymbol<*>? {
         return classCache.lookupCacheOrCalculate(classId) {
             val index = KotlinFullClassNameIndex.getInstance()
 
@@ -91,15 +91,15 @@ class IdeFirDependenciesSymbolProvider(
         }
     }
 
-    private fun tryJava(classId: ClassId): ConeClassLikeSymbol? {
+    private fun tryJava(classId: ClassId): FirClassLikeSymbol<*>? {
         return javaSymbolProvider.getClassLikeSymbolByFqName(classId)
     }
 
-    override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? {
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? {
         return tryKotlin(classId) ?: tryJava(classId)
     }
 
-    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<ConeCallableSymbol> {
+    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> {
         // TODO
         return emptyList()
     }

idea/tests/org/jetbrains/kotlin/idea/fir/AbstractFirMultiModuleResolveTest.kt

@@ -32,7 +32,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
 import org.jetbrains.kotlin.fir.service
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
 import org.jetbrains.kotlin.idea.caches.project.isLibraryClasses
@@ -159,7 +158,7 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
                                     renderedDeclarations += declaration
                                 } else {
                                     enhancementScope.processFunctionsByName(declaration.name) { symbol ->
-                                        val enhanced = (symbol as? FirFunctionSymbol)?.fir
+                                        val enhanced = symbol.fir
                                         if (enhanced != null && enhanced !in renderedDeclarations) {
                                             enhanced.accept(renderer, null)
                                             renderer.newLine()