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

This commit also fixes work with Java synthetic properties
2019-06-24 15:17:11 +03:00
parent 701b9ce166
commit c35d7eab70
99 changed files with 609 additions and 610 deletions
@@ -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 {
@@ -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)
 }
@@ -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
    }

@@ -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")
        }
    }
 }
@@ -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)
    }

@@ -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.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.symbols.impl.*
 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) {
-                    val originalFunction = functionSymbol.fir as FirNamedFunction
+                if (functionSymbol is FirNamedFunctionSymbol) {
+                    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) {
-                constructorSymbol = it
-                ProcessorAction.STOP
-            } else {
-                ProcessorAction.NEXT
+            when {
+                it !is FirConstructorSymbol -> ProcessorAction.NEXT
+                arguments.size <= it.fir.valueParameters.size -> {
+                    constructorSymbol = it
+                    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
@@ -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.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.symbols.impl.*
 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 javaClass = symbol.firUnsafe<FirJavaClass>()
-        return buildJavaEnhancementScope(useSiteSession, javaClass.symbol, scopeSession)
+        val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null
+        return buildJavaEnhancementScope(useSiteSession, 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,
@@ -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,
@@ -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.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol
 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,
@@ -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.types.FirTypeRef
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.name.Name

 class FirJavaMethod(
    session: FirSession,
-    symbol: FirFunctionSymbol,
+    symbol: FirNamedFunctionSymbol,
    name: Name,
    visibility: Visibility,
    modality: Modality?,
@@ -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 (result) {
+        val kotlinJvmBinaryClass = when (val result = kotlinClassFinder.findKotlinClassOrContent(classId)) {
            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)
        }
@@ -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)
@@ -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.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
 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 {
-        when (val firElement = (original as FirBasedSymbol<*>).fir) {
+    ): FirCallableSymbol<*> {
+        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 {
-        val firMethod = (original as FirFunctionSymbol).fir as? FirFunction
+    ): FirFunctionSymbol<*> {
+        val firMethod = original.fir

-        if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor || firMethod !is FirCallableMemberDeclaration) return original
-        return enhanceMethod(firMethod, original.callableId, name) as FirFunctionSymbol
+        if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor) {
+            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 {
-        require(firMethod is FirCallableMemberDeclaration)
+    ): FirFunctionSymbol<*> {
        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,
-                newReceiverTypeRef, newReturnTypeRef
+                this@JavaClassEnhancementScope.session, null,
+                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,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        ownerFunction: FirCallableMemberDeclaration<*>,
+        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
        hasReceiver: Boolean,
        memberContext: FirJavaEnhancementContext,
        predefinedEnhancementInfo: PredefinedFunctionEnhancementInfo?,
@@ -297,8 +296,8 @@ class JavaClassEnhancementScope(
    }

    private fun enhanceReturnType(
-        owner: FirCallableMemberDeclaration,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        owner: 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,
@@ -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.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
 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 {
-        overriddenInJava as FirCallableMemberDeclaration
-        val receiverTypeRef = (base as FirCallableMemberDeclaration).receiverTypeRef
+    private fun isOverriddenFunCheck(overriddenInJava: FirNamedFunction, base: FirNamedFunction): Boolean {
+        val receiverTypeRef = base.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 -> {
-                val self = firUnsafe<FirFunction>()
-                self as FirCallableMemberDeclaration
+            is FirNamedFunctionSymbol -> {
+                val self = this.fir
                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 -> {
-                            val overridden = it.fir as FirNamedFunction
+                        is FirNamedFunctionSymbol -> {
+                            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 {
-        val overrideCandidates = mutableSetOf<ConeFunctionSymbol>()
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+        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) {
-                                true -> if (fir.valueParameters.isNotEmpty()) {
-                                    return@processFunctionsByName NEXT
-                                }
-                                false -> if (fir.valueParameters.size != 1) {
-                                    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<*>) {
-                        (functionSymbol.fir as? FirCallableMemberDeclaration)?.let { callableMember -> accessorSymbol.bind(callableMember) }
+                    if (functionSymbol is FirNamedFunctionSymbol) {
+                        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)
    }
@@ -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,
@@ -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,
@@ -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(),
@@ -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
@@ -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.FirPropertySymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
 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)

@@ -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.FirTypeAliasSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 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 declaration = symbol.firUnsafe<FirTypeParameterImpl>()
+            val symbol = typeParameterDescriptors[proto.id]!!
+            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) {
-        is FirTypeAliasSymbol -> fir.typeParameters
-        is FirClassSymbol -> fir.typeParameters
-        else -> error("?!id:2")
-    }.map {
-        it.symbol
-    }
+    fun FirClassLikeSymbol<*>.typeParameters(): List<ConeTypeParameterSymbol> = fir.typeParameters.map { it.symbol }

    fun simpleType(proto: ProtoBuf.Type): ConeLookupTagBasedType? {

@@ -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.ConeClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName

 abstract class AbstractFirSymbolProvider : FirSymbolProvider() {
-    protected val classCache = HashMap<ClassId, ConeClassLikeSymbol?>()
-    protected val topLevelCallableCache = HashMap<CallableId, List<ConeCallableSymbol>>()
+    protected val classCache = HashMap<ClassId, FirClassLikeSymbol<*>?>()
+    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? {
@@ -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
@@ -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(
@@ -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)
 }
@@ -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 = toSymbol.firUnsafe<FirTypeParameter>()
+            val fir = lookupTag.toSymbol().fir
            FirCompositeScope(
                fir.bounds.mapNotNullTo(mutableListOf()) {
                    it.coneTypeUnsafe<ConeKotlinType>().scope(useSiteSession, scopeSession)
@@ -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
@@ -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.FirClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
 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> {
-        object Properties : Token<ConePropertySymbol>()
+    sealed class Token<out T : FirBasedSymbol<*>> {
+        object Properties : Token<FirPropertySymbol>()

-        object Functions : Token<ConeFunctionSymbol>()
-        object Objects : Token<ConeClassifierSymbol>()
+        object Functions : Token<FirFunctionSymbol<*>>()
+        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>()
-                if (fir.isStatic || it.callableId.classId == null) {
+                val fir = it.fir
+                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
@@ -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
@@ -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>()
-        if (declaration !is FirCallableMemberDeclaration || declaration.typeParameters.isEmpty()) {
+        val declaration = candidate.symbol.fir
+        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>> {
@@ -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 (declaration) {
+        return when (val declaration = call.symbol.fir) {
            is FirNamedFunction -> createFlatSignature(call, declaration)
            is FirConstructor -> createFlatSignature(call, declaration)
            else -> error("Not supported: $declaration")
@@ -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 function = symbol.firUnsafe<FirFunction>()
+        val symbol = candidate.symbol as? FirFunctionSymbol<*> ?: return sink.reportApplicability(CandidateApplicability.HIDDEN)
+        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>()
-        if (declaration != null && !declaration.visibility.isPublicAPI) {
+        val declaration = symbol.fir
+        if (declaration is FirMemberDeclaration && !declaration.visibility.isPublicAPI) {
            val visible = when (declaration.visibility) {
                JavaVisibilities.PACKAGE_VISIBILITY ->
                    symbol.packageFqName() == callInfo.containingFile.packageFqName
@@ -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,
-        processor: (ConeVariableSymbol) -> ProcessorAction
+        symbol: FirFunctionSymbol<*>,
+        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)
@@ -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.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
@@ -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) }
    }

@@ -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.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
@@ -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 {
@@ -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> {
@@ -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? {
-        return (getFirClassifierByFqName(classId) as? FirSymbolOwner<*>)?.symbol as? ConeClassLikeSymbol
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? {
+        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) {
-                val symbol = callableMemberDeclaration.symbol as ConeCallableSymbol
+            override fun <F : FirCallableMemberDeclaration<F>> visitCallableMemberDeclaration(
+                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]
    }

@@ -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)!!
        }
    }

@@ -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) {
-                    val returnType = jump.tryCalculateReturnType(symbol.firUnsafe())
+                if (symbol is FirCallableSymbol<*>) {
+                    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) {
-                    val firUnsafe = symbol.firUnsafe<FirElement>()
+                } else if (symbol is ConeClassifierSymbol && symbol is FirBasedSymbol<*>) {
+                    val fir = symbol.fir
                    // TODO: unhack
-                    if (firUnsafe is FirEnumEntry) {
-                        (firUnsafe.superTypeRefs.firstOrNull() as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(
+                    if (fir is FirEnumEntry) {
+                        (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> {
-        val variable = super.transformVariable(variable, variable.returnTypeRef).single as FirVariable
+    override fun <F : FirVariable<F>> transformVariable(variable: FirVariable<F>, data: Any?): CompositeTransformResult<FirDeclaration> {
+        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
@@ -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) }
@@ -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
@@ -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
        }
@@ -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.ConeFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 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 (expandedType) {
+    return when (val expandedType = symbol.fir.expandedTypeRef.coneTypeUnsafe<ConeClassLikeType>()) {
        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?,
-    processor: (ConeFunctionSymbol) -> ProcessorAction,
+    matchedSymbol: FirClassLikeSymbol<*>?,
+    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?
@@ -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?
@@ -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) {
-            val expansionSymbol = symbol.firUnsafe<FirTypeAlias>().expandedConeType?.lookupTag?.toSymbol(session)
-            if (expansionSymbol as? ConeClassLikeSymbol != null) {
+        if (symbol is FirTypeAliasSymbol) {
+            val expansionSymbol = symbol.fir.expandedConeType?.lookupTag?.toSymbol(session)
+            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
@@ -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 {


@@ -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()) {
@@ -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 {
-        val result = mutableMapOf<Name, MutableList<FirCallableSymbol>>()
+    private val callablesIndex: Map<Name, List<FirCallableSymbol<*>>> = run {
+        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
            }
        }
@@ -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.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+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 {
-
-        val member = original.firUnsafe<FirFunction>()
-        if (member is FirConstructor) return original as FirFunctionSymbol // TODO: substitution for constructors
-        member as FirNamedFunction
+    private fun createFakeOverride(original: FirFunctionSymbol<*>): FirFunctionSymbol<*> {
+        val member = when (original) {
+            is FirNamedFunctionSymbol -> original.fir
+            is FirConstructorSymbol -> return original
+            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 {
-            val symbol = FirFunctionSymbol(baseSymbol.callableId, true, baseSymbol)
+        ): FirNamedFunctionSymbol {
+            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
@@ -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
@@ -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)
    }

@@ -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.ConeVariableSymbol
+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.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.Name

 class FirLocalScope : FirScope() {

-    val properties = mutableMapOf<Name, ConeVariableSymbol>()
-    val functions = mutableMapOf<Name, ConeFunctionSymbol>()
+    val properties = mutableMapOf<Name, FirVariableSymbol<*>>()
+    val functions = mutableMapOf<Name, FirFunctionSymbol<*>>()

    fun storeDeclaration(declaration: FirNamedDeclaration) {
        when (declaration) {
-            is FirVariable -> properties[declaration.name] = declaration.symbol
-            is FirNamedFunction -> functions[declaration.name] = declaration.symbol as FirFunctionSymbol
+            is FirVariable<*> -> properties[declaration.name] = declaration.symbol
+            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)
@@ -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 {
-        val accepted = HashSet<ConeCallableSymbol>()
-        val pending = mutableListOf<ConeVariableSymbol>()
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
+        val accepted = HashSet<FirCallableSymbol<*>>()
+        val pending = mutableListOf<FirCallableSymbol<*>>()
        for (scope in scopes) {
            if (scope.processPropertiesByName(name) {
                    if (it !in accepted && it.isOverridden(accepted) == null) {
@@ -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)) {
@@ -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.Nothing: ConeClassLikeSymbol get() = this.getClassLikeSymbolByFqName(StandardClassIds.Nothing)!!
+val FirSymbolProvider.Any: FirClassLikeSymbol<*> get() = this.getClassLikeSymbolByFqName(StandardClassIds.Any)!!
+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)!!
 }
@@ -277,8 +277,8 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext {
    }

    override fun TypeConstructorMarker.isCommonFinalClassConstructor(): Boolean {
-        val classSymbol = this as? ConeClassSymbol ?: return false
-        val fir = (classSymbol as FirClassSymbol).fir
+        val classSymbol = this as? FirClassSymbol ?: return false
+        val fir = classSymbol.fir
        return fir.modality == Modality.FINAL &&
                fir.classKind != ClassKind.ENUM_ENTRY &&
                fir.classKind != ClassKind.ANNOTATION_CLASS
@@ -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()
            }
        }
@@ -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()
            }
        }
@@ -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
-                                    if (enhanced != null && enhanced !in renderedDeclarations) {
+                                    val enhanced = symbol.fir
+                                    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
-                                    if (enhanced != null && enhanced !in renderedDeclarations) {
+                                    val enhanced = symbol.fir
+                                    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
-                                    if (enhanced != null && enhanced !in renderedDeclarations) {
+                                    val enhanced = symbol.fir
+                                    if (enhanced !in renderedDeclarations) {
                                        enhanced.accept(renderer, null)
                                        renderer.newLine()
                                        renderedDeclarations += enhanced
@@ -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)
                }
@@ -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?

@@ -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

@@ -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 {
-    val symbol: ConeClassLikeSymbol
+interface FirClassLikeDeclaration<F : FirClassLikeDeclaration<F>> :
+    @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
@@ -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

@@ -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)

@@ -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)
+    }
+}
@@ -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)
-    }
 }
@@ -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
@@ -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
@@ -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
@@ -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)
@@ -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

@@ -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) {
@@ -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 {
@@ -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?,
@@ -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)
@@ -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,
@@ -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 {
@@ -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)
@@ -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)
@@ -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>

@@ -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>()

@@ -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
@@ -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.ConeVariableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+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
 }

@@ -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

@@ -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()
@@ -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>()
@@ -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()
@@ -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()
-}
@@ -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
@@ -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(
-    override val callableId: CallableId,
-    val isFakeOverride: Boolean = false,
-    // Actual for fake override only
-    val overriddenSymbol: FirFunctionSymbol? = null
-) : ConeFunctionSymbol, FirCallableSymbol() {
+sealed class FirFunctionSymbol<D : FirMemberFunction<D>>(
+    override val callableId: CallableId
+) : ConeFunctionSymbol, FirCallableSymbol<D>() {
    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)
@@ -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()
@@ -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
-
-class FirBackingFieldSymbol(callableId: CallableId) : FirVariableSymbol(callableId)
-
-open class FirVariableSymbol(override val callableId: CallableId) : ConeVariableSymbol, FirCallableSymbol() {
+open class FirVariableSymbol<D : FirVariable<D>>(override val callableId: CallableId) : ConeVariableSymbol, FirCallableSymbol<D>() {

    @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)
@@ -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)
    }

@@ -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)
    }

@@ -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)
    }

@@ -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
@@ -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
@@ -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.ConeClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+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()
    }
@@ -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()