FIR: Get rid of CallableId::classId usages

Use dispatchReceiverType or containingClassAttr instead
2020-10-23 17:04:41 +03:00
parent 9996c983c9
commit 4d9ef4d414
31 changed files with 152 additions and 151 deletions
@@ -7,11 +7,12 @@ package org.jetbrains.kotlin.fir.analysis.checkers

 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
@@ -23,7 +24,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.firClassLike
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.processOverriddenFunctions
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
@@ -142,18 +142,8 @@ inline fun <reified T : Any> FirQualifiedAccessExpression.getDeclaration(): T? {
 * Returns the ClassLikeDeclaration where the Fir object has been defined
 * or null if no proper declaration has been found.
 */
-fun FirSymbolOwner<*>.getContainingClass(context: CheckerContext): FirClassLikeDeclaration<*>? {
-    val classId = this.symbol.safeAs<FirCallableSymbol<*>>()
-        ?.callableId
-        ?.classId
-        ?: return null
-
-    if (!classId.isLocal) {
-        return context.session.firSymbolProvider.getClassLikeSymbolByFqName(classId)?.fir
-    }
-
-    return null
-}
+fun FirSymbolOwner<*>.getContainingClass(context: CheckerContext): FirClassLikeDeclaration<*>? =
+    this.safeAs<FirCallableMemberDeclaration<*>>()?.containingClass()?.toSymbol(context.session)?.fir

 /**
 * Returns the FirClassLikeDeclaration the type alias is pointing
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClass
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
@@ -15,8 +16,6 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.FirSuperReference
-import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
-import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs

@@ -45,17 +44,7 @@ object FirSuperclassNotAccessibleFromInterfaceChecker : FirQualifiedAccessChecke
     * or null if no proper declaration has been found.
     */
    private fun getClassLikeDeclaration(functionCall: FirQualifiedAccessExpression, context: CheckerContext): FirClassLikeDeclaration<*>? {
-        val classId = functionCall.calleeReference.safeAs<FirResolvedNamedReference>()
-            ?.resolvedSymbol.safeAs<FirNamedFunctionSymbol>()
-            ?.callableId
-            ?.classId
-            ?: return null
-
-        if (!classId.isLocal) {
-            return context.session.firSymbolProvider.getClassLikeSymbolByFqName(classId)?.fir
-        }
-
-        return null
+        return functionCall.calleeReference.safeAs<FirResolvedNamedReference>()?.resolvedSymbol?.fir?.getContainingClass(context)
    }

    private fun DiagnosticReporter.report(source: FirSourceElement?) {
@@ -63,4 +52,4 @@ object FirSuperclassNotAccessibleFromInterfaceChecker : FirQualifiedAccessChecke
            report(FirErrors.SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE.on(it))
        }
    }
-}
+}
@@ -9,9 +9,7 @@ import com.intellij.lang.LighterASTNode
 import com.intellij.openapi.util.Ref
 import com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirLightSourceElement
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirExpressionChecker
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -20,7 +18,6 @@ import org.jetbrains.kotlin.fir.analysis.getChild
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
 import org.jetbrains.kotlin.fir.expressions.toResolvedCallableSymbol
-import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.types.classId
@@ -41,7 +38,7 @@ object CanBeReplacedWithOperatorAssignmentChecker : FirExpressionChecker<FirVari
        val rValueClassId = rValue.explicitReceiver?.typeRef?.coneType?.classId
        if (rValueClassId !in StandardClassIds.primitiveTypes) return
        val rValueResolvedSymbol = rValue.toResolvedCallableSymbol() ?: return
-        if (rValueResolvedSymbol.callableId.classId !in StandardClassIds.primitiveTypes) return
+        if (rValueResolvedSymbol.dispatchReceiverClassOrNull()?.classId !in StandardClassIds.primitiveTypes) return

        var needToReport = false
        val assignmentSource = expression.source
@@ -144,4 +141,4 @@ object CanBeReplacedWithOperatorAssignmentChecker : FirExpressionChecker<FirVari
    private fun LighterASTNode.canBeAugmented() = this.toString().let {
        it == "+" || it == "*" || it == "-" || it == "/" || it == "%"
    }
-}
+}
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.lexer.KtTokens

 object UnusedChecker : FirControlFlowChecker() {
    override fun analyze(graph: ControlFlowGraph, reporter: DiagnosticReporter, checkerContext: CheckerContext) {
-        if ((graph.declaration as? FirSymbolOwner<*>)?.getContainingClass(checkerContext) != null) return
+        if ((graph.declaration as? FirSymbolOwner<*>)?.getContainingClass(checkerContext)?.takeIf { !it.symbol.classId.isLocal }!= null) return
        val properties = LocalPropertyCollector.collect(graph)
        if (properties.isEmpty()) return

@@ -203,4 +203,4 @@ object UnusedChecker : FirControlFlowChecker() {

    private val FirPropertySymbol.identifierSource: FirSourceElement?
        get() = fir.source?.getChild(KtTokens.IDENTIFIER, 0, 1)
-}
+}
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.backend.common.serialization.mangle.MangleMode
 import org.jetbrains.kotlin.backend.common.serialization.mangle.collectForMangler
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
@@ -75,7 +76,7 @@ open class FirJvmMangleComputer(

    private fun FirDeclaration.visitParent() {
        val (parentPackageFqName, parentClassId) = when (this) {
-            is FirCallableDeclaration<*> -> this.symbol.callableId.let { it.packageName to it.classId }
+            is FirCallableMemberDeclaration<*> -> this.containingClass()?.classId?.let { it.packageFqName to it } ?: return
            is FirClassLikeDeclaration<*> -> this.symbol.classId.let { it.packageFqName to it.outerClassId }
            else -> return
        }
@@ -10,8 +10,8 @@ import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.JvmDefaultMode
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.backend.FirMetadataSource
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.firProvider
@@ -279,7 +279,7 @@ class FirJvmSerializerExtension(
        if (!hasJvmFieldAnnotation) return false

        val container =
-            symbol.callableId.classId?.let {
+            dispatchReceiverType?.classId?.let {
                session.firProvider.getFirClassifierByFqName(it) as? FirRegularClass
            }
        if (container == null || !container.isCompanion) {
@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.SyntheticPropertySymbol
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
+import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
 import org.jetbrains.kotlin.fir.scopes.processDirectlyOverriddenFunctions
 import org.jetbrains.kotlin.fir.scopes.processDirectlyOverriddenProperties
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
@@ -218,7 +219,9 @@ internal tailrec fun FirCallableSymbol<*>.deepestOverriddenSymbol(): FirCallable

 internal tailrec fun FirCallableSymbol<*>.deepestMatchingOverriddenSymbol(root: FirCallableSymbol<*> = this): FirCallableSymbol<*> {
    if (isIntersectionOverride) return this
-    val overriddenSymbol = overriddenSymbol?.takeIf { it.callableId == root.callableId } ?: return this
+    val overriddenSymbol = overriddenSymbol?.takeIf {
+        it.containingClass() == root.containingClass()
+    } ?: return this
    return overriddenSymbol.deepestMatchingOverriddenSymbol(this)
 }

@@ -235,7 +238,11 @@ internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(
        if ((it.fir as FirSimpleFunction).visibility == Visibilities.Private) {
            return@processDirectlyOverriddenFunctions ProcessorAction.NEXT
        }
-        val overridden = declarationStorage.getIrFunctionSymbol(it.unwrapSubstitutionOverrides())
+
+        val unwrapped =
+            it.fir.delegatedWrapperData?.takeIf { it.containingClass == containingClass.symbol.toLookupTag() }?.wrapped?.symbol ?: it
+
+        val overridden = declarationStorage.getIrFunctionSymbol(unwrapped.unwrapSubstitutionOverrides())
        overriddenSet += overridden as IrSimpleFunctionSymbol
        ProcessorAction.NEXT
    }
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.backend
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.builtins.StandardNames.BUILT_INS_PACKAGE_FQ_NAMES
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.fir.FirAnnotationContainer
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.backend.generators.AnnotationGenerator
 import org.jetbrains.kotlin.fir.backend.generators.DelegatedMemberGenerator
 import org.jetbrains.kotlin.fir.declarations.*
@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.fir.lazy.Fir2IrLazyClass
 import org.jetbrains.kotlin.fir.lazy.Fir2IrLazyConstructor
 import org.jetbrains.kotlin.fir.lazy.Fir2IrLazyProperty
 import org.jetbrains.kotlin.fir.lazy.Fir2IrLazySimpleFunction
-import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.inference.isSuspendFunctionType
@@ -236,7 +235,7 @@ class Fir2IrDeclarationStorage(
    internal fun findIrParent(callableDeclaration: FirCallableDeclaration<*>): IrDeclarationParent? {
        val firBasedSymbol = callableDeclaration.symbol
        val callableId = firBasedSymbol.callableId
-        return findIrParent(callableId.packageName, callableId.classId, firBasedSymbol)
+        return findIrParent(callableId.packageName, callableDeclaration.containingClass()?.classId, firBasedSymbol)
    }

    private fun IrDeclaration.setAndModifyParent(irParent: IrDeclarationParent?) {
@@ -977,7 +976,8 @@ class Fir2IrDeclarationStorage(
        val firConstructor = firConstructorSymbol.fir
        getCachedIrConstructor(firConstructor)?.let { return it.symbol }
        val signature = signatureComposer.composeSignature(firConstructor)
-        val irParent = findIrParent(firConstructor) as IrClass
+        val irParent = findIrParent(firConstructor) as? IrClass
+            ?: error("sadsad")
        val parentOrigin = irParent.origin
        if (signature != null) {
            symbolTable.referenceConstructorIfAny(signature)?.let { irConstructorSymbol ->
@@ -1100,7 +1100,7 @@ class Fir2IrDeclarationStorage(
                    symbolTable.declareProperty(signature, { symbol }) {
                        val isFakeOverride =
                            firPropertySymbol.isFakeOverride &&
-                                    firPropertySymbol.callableId != firPropertySymbol.overriddenSymbol?.callableId
+                                    firPropertySymbol.dispatchReceiverClassOrNull() != firPropertySymbol.overriddenSymbol?.dispatchReceiverClassOrNull()
                        Fir2IrLazyProperty(
                            components, startOffset, endOffset, declarationOrigin, fir, irParent.fir, symbol, isFakeOverride
                        ).apply {
@@ -1154,7 +1154,7 @@ class Fir2IrDeclarationStorage(
            is FirEnumEntry -> {
                classifierStorage.getCachedIrEnumEntry(firDeclaration)?.let { return it.symbol }
                val containingFile = firProvider.getFirCallableContainerFile(firVariableSymbol)
-                val irParentClass = firVariableSymbol.callableId.classId?.let { findIrClass(it) }
+                val irParentClass = firDeclaration.containingClass()?.classId?.let { findIrClass(it) }
                classifierStorage.createIrEnumEntry(
                    firDeclaration,
                    irParent = irParentClass,
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.backend.generators
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.dispatchReceiverClassOrNull
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.psi
@@ -401,9 +402,9 @@ class CallAndReferenceGenerator(
                    return null
                }
                val resolvedReference = callableReferenceAccess.calleeReference as FirResolvedNamedReference
-                val callableId = (resolvedReference.resolvedSymbol as FirCallableSymbol<*>).callableId
+                val firCallableSymbol = resolvedReference.resolvedSymbol as FirCallableSymbol<*>
                // Make sure the reference indeed refers to a member of that companion
-                if (callableId.classId != classSymbol.classId) {
+                if (firCallableSymbol.dispatchReceiverClassOrNull() != classSymbol.toLookupTag()) {
                    return null
                }
            }
@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
+import org.jetbrains.kotlin.fir.dispatchReceiverClassOrNull
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
@@ -124,7 +125,7 @@ internal class ClassMemberGenerator(
                        irFunction.body = IrSyntheticBodyImpl(startOffset, endOffset, kind)
                    }
                    irFunction.parent is IrClass && irFunction.parentAsClass.isData -> {
-                        val classId = firFunction?.symbol?.callableId?.classId
+                        val classId = firFunction?.symbol?.dispatchReceiverClassOrNull()?.classId
                        when {
                            DataClassMembersGenerator.isComponentN(irFunction) ->
                                firFunction?.body?.let { irFunction.body = visitor.convertToIrBlockBody(it) }
@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.PossiblyFirFakeOverrideSymbol
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrBlockBody
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
@@ -84,7 +85,7 @@ internal class DelegatedMemberGenerator(
        }
    }

-    private inline fun <reified S, reified D : FirCallableDeclaration<D>> S.unwrapDelegateTarget(
+    private inline fun <reified S, reified D : FirCallableMemberDeclaration<D>> S.unwrapDelegateTarget(
        subClassLookupTag: ConeClassLikeLookupTag,
        noinline directOverridden: S.() -> List<S>,
        firField: FirField,
@@ -103,7 +104,8 @@ internal class DelegatedMemberGenerator(
        val wrappedSymbol = wrapped.symbol as? S ?: return null

        return when {
-            wrappedSymbol.isFakeOverride && wrappedSymbol.callableId.classId == firSubClass.classId ->
+            wrappedSymbol.isFakeOverride &&
+                    (wrappedSymbol.fir.dispatchReceiverType as? ConeClassLikeType)?.lookupTag == firSubClass.symbol.toLookupTag() ->
                wrapped.symbol.overriddenSymbol!!.fir
            else -> wrapped
        }
@@ -149,16 +149,16 @@ class FakeOverrideGenerator(
        scope: FirTypeScope,
    ) where S : FirCallableSymbol<D>, S : PossiblyFirFakeOverrideSymbol<D, S> {
        if (originalSymbol !is S || originalSymbol in realDeclarationSymbols) return
-        val classId = klass.symbol.classId
+        val classLookupTag = klass.symbol.toLookupTag()
        val originalDeclaration = originalSymbol.fir
-        if (originalSymbol.callableId.classId == classId && !originalDeclaration.origin.fromSupertypes) return
+        if (originalSymbol.dispatchReceiverClassOrNull() == classLookupTag && !originalDeclaration.origin.fromSupertypes) return
        if (originalDeclaration.visibility == Visibilities.Private) return

        val origin = IrDeclarationOrigin.FAKE_OVERRIDE
        val baseSymbol = originalSymbol.deepestOverriddenSymbol() as S

        if ((originalSymbol.isFakeOverride || originalSymbol.isIntersectionOverride) &&
-            originalSymbol.callableId.classId == classId
+            originalSymbol.dispatchReceiverClassOrNull() == classLookupTag
        ) {
            // Substitution case
            // NB: see comment above about substituted function' parent
@@ -170,7 +170,7 @@ class FakeOverrideGenerator(
                    isLocal
                )
            irDeclaration.parent = irClass
-            baseSymbols[irDeclaration] = computeBaseSymbols(originalSymbol, baseSymbol, computeDirectOverridden, scope, classId)
+            baseSymbols[irDeclaration] = computeBaseSymbols(originalSymbol, baseSymbol, computeDirectOverridden, scope, classLookupTag)
            result += irDeclaration
        } else if (originalDeclaration.allowsToHaveFakeOverrideIn(klass)) {
            // Trivial fake override case
@@ -189,7 +189,7 @@ class FakeOverrideGenerator(
                return
            }
            irDeclaration.parent = irClass
-            baseSymbols[irDeclaration] = computeBaseSymbols(originalSymbol, baseSymbol, computeDirectOverridden, scope, classId)
+            baseSymbols[irDeclaration] = computeBaseSymbols(originalSymbol, baseSymbol, computeDirectOverridden, scope, classLookupTag)
            result += irDeclaration
        }
    }
@@ -199,12 +199,12 @@ class FakeOverrideGenerator(
        basedSymbol: S,
        directOverridden: FirTypeScope.(S) -> List<S>,
        scope: FirTypeScope,
-        containingClassId: ClassId,
+        containingClass: ConeClassLikeLookupTag,
    ): List<S> {
        if (!symbol.isIntersectionOverride) return listOf(basedSymbol)
        return scope.directOverridden(symbol).map {
            @Suppress("UNCHECKED_CAST")
-            if (it is PossiblyFirFakeOverrideSymbol<*, *> && it.isFakeOverride && it.callableId.classId == containingClassId)
+            if (it is PossiblyFirFakeOverrideSymbol<*, *> && it.isFakeOverride && it.dispatchReceiverClassOrNull() == containingClass)
                it.overriddenSymbol!! as S
            else
                it
@@ -5,14 +5,12 @@

 package org.jetbrains.kotlin.fir.lazy

-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.SourceElement
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
 import org.jetbrains.kotlin.fir.backend.declareThisReceiverParameter
 import org.jetbrains.kotlin.fir.backend.toIrType
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.dispatchReceiverClassOrNull
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.Fir2IrClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -26,7 +24,6 @@ import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.descriptors.DescriptorVisibility

 class Fir2IrLazyClass(
    components: Fir2IrComponents,
@@ -140,7 +137,7 @@ class Fir2IrLazyClass(
                            result += declarationStorage.getIrFunctionSymbol(declaration.symbol).owner
                        } else {
                            scope.processFunctionsByName(declaration.name) {
-                                if (it is FirNamedFunctionSymbol && it.callableId.classId == fir.symbol.classId) {
+                                if (it is FirNamedFunctionSymbol && it.dispatchReceiverClassOrNull() == fir.symbol.toLookupTag()) {
                                    if (it.isAbstractMethodOfAny()) {
                                        return@processFunctionsByName
                                    }
@@ -6,16 +6,12 @@
 package org.jetbrains.kotlin.fir.signaturer

 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.NoMutableState
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.backend.Fir2IrSignatureComposer
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.ir.util.IdSignature
-import org.jetbrains.kotlin.name.FqName

@NoMutableState
 class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatureComposer {
@@ -60,14 +56,12 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu
        }
    }

-    private val CallableId.relativeCallableName: FqName
-        get() = className?.child(callableName) ?: FqName.topLevel(callableName)
-
    override fun composeSignature(declaration: FirDeclaration, containingClass: ConeClassLikeLookupTag?): IdSignature? {
        if (declaration is FirAnonymousObject || declaration is FirAnonymousFunction) return null
        if (declaration is FirRegularClass && declaration.classId.isLocal) return null
        if (declaration is FirCallableMemberDeclaration<*>) {
-            if (declaration.visibility == Visibilities.Local || declaration.symbol.callableId.classId?.isLocal == true || containingClass?.classId?.isLocal == true) return null
+            if (declaration.visibility == Visibilities.Local) return null
+            if (declaration.symbol.dispatchReceiverClassOrNull()?.classId?.isLocal == true || containingClass?.classId?.isLocal == true) return null
        }
        val builder = SignatureBuilder()
        try {
@@ -93,11 +87,15 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu
            is FirCallableMemberDeclaration<*> -> {
                if (declaration.visibility == Visibilities.Private) return null
                val containingClassId = containingClass?.classId
-                val baseCallableId = declaration.symbol.callableId
-                val callableId =
-                    if (containingClassId != null) CallableId(containingClassId, baseCallableId.callableName) else baseCallableId
+
+                val classId = containingClassId ?: declaration.containingClass()?.classId
+                val packageName = classId?.packageFqName ?: declaration.symbol.callableId.packageName
+                val callableName = declaration.symbol.callableId.callableName
+
                IdSignature.PublicSignature(
-                    callableId.packageName.asString(), callableId.relativeCallableName.asString(), builder.hashId, builder.mask
+                    packageName.asString(),
+                    classId?.relativeClassName?.child(callableName)?.asString() ?: callableName.asString(),
+                    builder.hashId, builder.mask
                )
            }
            else -> error("Unsupported FIR declaration in signature composer: ${declaration.render()}")
@@ -5,6 +5,7 @@

 package org.jetbrains.kotlin.fir.resolve.calls.jvm

+import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.calls.AbstractConeCallConflictResolver
 import org.jetbrains.kotlin.fir.resolve.calls.Candidate
@@ -31,10 +32,10 @@ class ConeEquivalentCallConflictResolver(
        val result = mutableSetOf<Candidate>()
        outerLoop@ for (myCandidate in candidates) {
            val me = myCandidate.symbol.fir
-            if (me is FirCallableMemberDeclaration<*> && me.symbol.callableId.className == null) {
+            if (me is FirCallableMemberDeclaration<*> && me.symbol.containingClass() == null) {
                for (otherCandidate in result) {
                    val other = otherCandidate.symbol.fir
-                    if (other is FirCallableMemberDeclaration<*> && other.symbol.callableId.className == null) {
+                    if (other is FirCallableMemberDeclaration<*> && other.symbol.containingClass() == null) {
                        if (areEquivalentTopLevelCallables(me, myCandidate, other, otherCandidate)) {
                            continue@outerLoop
                        }
@@ -71,4 +72,4 @@ class ConeEquivalentCallConflictResolver(
            else -> error("Not supported: $declaration")
        }
    }
-}
+}
@@ -117,13 +117,13 @@ open class FirEffectiveVisibilityResolverImpl(private val session: FirSession) :
    }

    private fun FirDeclaration.getParentClassId(): ClassId? = when (this) {
-        is FirCallableMemberDeclaration<*> -> this.symbol.callableId.classId
+        is FirCallableMemberDeclaration<*> -> this.containingClass()?.classId
        is FirClassLikeDeclaration<*> -> this.symbol.classId.outerClassId
        else -> null
    }

    private fun FirDeclaration.getClassId(): ClassId? = when (this) {
-        is FirCallableMemberDeclaration<*> -> this.symbol.callableId.classId
+        is FirCallableMemberDeclaration<*> -> this.containingClass()?.classId
        is FirClassLikeDeclaration<*> -> this.symbol.classId
        else -> null
    }
@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.PossiblyFirFakeOverrideSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -38,11 +39,17 @@ abstract class FirVisibilityChecker : FirSessionComponent {
        }
    }

-    fun isVisible(
-        declaration: FirMemberDeclaration,
-        symbol: AbstractFirBasedSymbol<*>,
+    fun <T> isVisible(
+        declaration: T,
        candidate: Candidate
-    ): Boolean {
+    ): Boolean where T : FirMemberDeclaration, T : FirSymbolOwner<*> {
+        val symbol = declaration.symbol
+
+        if (symbol is PossiblyFirFakeOverrideSymbol<*, *> && symbol.overriddenSymbol != null) {
+            @Suppress("UNCHECKED_CAST")
+            return isVisible(symbol.overriddenSymbol!!.fir as T, candidate)
+        }
+
        val callInfo = candidate.callInfo
        val useSiteFile = callInfo.containingFile
        val containingDeclarations = callInfo.containingDeclarations
@@ -174,7 +181,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
                    ownerId
                }
            }
-            is FirCallableSymbol<*> -> callableId.classId
+            is FirCallableSymbol<*> -> containingClass()?.classId
            else -> error("Unsupported owner search for ${fir.javaClass}: ${fir.render()}")
        }
    }
@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
 import org.jetbrains.kotlin.fir.references.FirSuperReference
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.inference.*
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.SyntheticSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
@@ -226,33 +225,31 @@ internal object CheckVisibility : CheckerStage() {
        val symbol = candidate.symbol
        val declaration = symbol.fir
        if (declaration is FirMemberDeclaration) {
-            if (!checkVisibility(declaration, symbol, sink, candidate, visibilityChecker)) {
+            if (!checkVisibility(declaration, sink, candidate, visibilityChecker)) {
                return
            }
        }

        if (declaration is FirConstructor) {
-            val ownerClassId = declaration.symbol.callableId.classId!!
-            val provider = declaration.session.firSymbolProvider
-            val classSymbol = provider.getClassLikeSymbolByFqName(ownerClassId)
+            // TODO: Should be some other form
+            val classSymbol = declaration.returnTypeRef.coneTypeUnsafe<ConeClassLikeType>().lookupTag.toSymbol(declaration.session)

            if (classSymbol is FirRegularClassSymbol) {
                if (classSymbol.fir.classKind.isSingleton) {
                    sink.yieldDiagnostic(HiddenCandidate)
                }
-                checkVisibility(classSymbol.fir, classSymbol, sink, candidate, visibilityChecker)
+                checkVisibility(classSymbol.fir, sink, candidate, visibilityChecker)
            }
        }
    }

-    private suspend fun checkVisibility(
-        declaration: FirMemberDeclaration,
-        symbol: AbstractFirBasedSymbol<*>,
+    private suspend fun <T> checkVisibility(
+        declaration: T,
        sink: CheckerSink,
        candidate: Candidate,
        visibilityChecker: FirVisibilityChecker
-    ): Boolean {
-        if (!visibilityChecker.isVisible(declaration, symbol, candidate)) {
+    ): Boolean where T : FirMemberDeclaration, T : FirSymbolOwner<*> {
+        if (!visibilityChecker.isVisible(declaration, candidate)) {
            sink.yieldDiagnostic(HiddenCandidate)
            return false
        }
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.modality
+import org.jetbrains.kotlin.fir.dispatchReceiverClassOrNull
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.references.FirNamedReference
@@ -146,5 +147,5 @@ private fun BodyResolveComponents.isConcreteMember(supertype: ConeKotlinType, me
    val classSymbol =
        (supertype as? ConeClassLikeType)?.lookupTag?.toSymbol(session) as? FirRegularClassSymbol ?: return true
    if (classSymbol.fir.classKind != ClassKind.INTERFACE) return true
-    return member.symbol.unwrapSubstitutionOverrides().callableId.classId != StandardClassIds.Any
+    return member.symbol.unwrapSubstitutionOverrides().dispatchReceiverClassOrNull()?.classId != StandardClassIds.Any
 }
@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.isStatic
 import org.jetbrains.kotlin.fir.declarations.synthetic.buildSyntheticProperty
+import org.jetbrains.kotlin.fir.dispatchReceiverClassOrNull
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
@@ -74,7 +75,7 @@ class FirSyntheticPropertiesScope(
                    val parameter = setter.valueParameters.singleOrNull() ?: return
                    if (setter.typeParameters.isNotEmpty() || setter.isStatic) return
                    val parameterType = (parameter.returnTypeRef as? FirResolvedTypeRef)?.type ?: return
-                    if (getter.symbol.callableId.classId == setter.symbol.callableId.classId) {
+                    if (getter.symbol.dispatchReceiverClassOrNull() == setter.symbol.dispatchReceiverClassOrNull()) {
                        if (getterReturnType.withNullability(NOT_NULL) != parameterType.withNullability(NOT_NULL)) {
                            return
                        }
@@ -102,12 +103,16 @@ class FirSyntheticPropertiesScope(
            }
        }

+        val classLookupTag = getterSymbol.dispatchReceiverClassOrNull()
+        val packageName = classLookupTag?.classId?.packageFqName ?: getterSymbol.callableId.packageName
+        val className = classLookupTag?.classId?.relativeClassName
+
        val property = buildSyntheticProperty {
            session = this@FirSyntheticPropertiesScope.session
            name = propertyName
            symbol = SyntheticPropertySymbol(
                accessorId = getterSymbol.callableId,
-                callableId = CallableId(getterSymbol.callableId.packageName, getterSymbol.callableId.className, propertyName)
+                callableId = CallableId(packageName, className, propertyName)
            )
            delegateGetter = getter
            delegateSetter = matchingSetter
@@ -9,22 +9,21 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.isInner
+import org.jetbrains.kotlin.fir.dispatchReceiverClassOrNull
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildResolvedQualifier
-import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.*
-import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
-import org.jetbrains.kotlin.fir.resolve.typeForQualifier
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
+import org.jetbrains.kotlin.fir.scopes.impl.importedFromObjectClassId
 import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.ConeNullability
-import org.jetbrains.kotlin.fir.types.classId
 import org.jetbrains.kotlin.fir.types.withNullability
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.util.OperatorNameConventions
@@ -190,13 +189,13 @@ class ScopeTowerLevel(
        }

    private fun dispatchReceiverValue(candidate: FirCallableSymbol<*>): ReceiverValue? {
-        val holderId = candidate.callableId.classId
-        if (holderId != null && candidate.fir.origin == FirDeclarationOrigin.ImportedFromObject) {
-            val symbol = session.firSymbolProvider.getClassLikeSymbolByFqName(holderId)
+        val lookupTag = candidate.dispatchReceiverClassOrNull()
+        candidate.fir.importedFromObjectClassId?.let { objectClassId ->
+            val symbol = session.firSymbolProvider.getClassLikeSymbolByFqName(objectClassId)
            if (symbol is FirRegularClassSymbol) {
                val resolvedQualifier = buildResolvedQualifier {
-                    packageFqName = holderId.packageFqName
-                    relativeClassFqName = holderId.relativeClassName
+                    packageFqName = objectClassId.packageFqName
+                    relativeClassFqName = objectClassId.relativeClassName
                    this.symbol = symbol
                }.apply {
                    resultType = bodyResolveComponents.typeForQualifier(this)
@@ -206,9 +205,9 @@ class ScopeTowerLevel(
        }
        return when {
            candidate !is FirBackingFieldSymbol -> null
-            candidate.callableId.classId != null -> {
+            lookupTag != null -> {
                bodyResolveComponents.implicitReceiverStack.lastDispatchReceiver { implicitReceiverValue ->
-                    implicitReceiverValue.type.classId == holderId
+                    (implicitReceiverValue.type as? ConeClassLikeType)?.fullyExpandedType(session)?.lookupTag == lookupTag
                }
            }
            else -> {
@@ -8,11 +8,10 @@ package org.jetbrains.kotlin.fir.resolve.dfa
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
 import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.modality
+import org.jetbrains.kotlin.fir.dispatchReceiverClassOrNull
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirThisReference
@@ -164,14 +163,14 @@ class VariableStorage(private val session: FirSession) {
            property.getter.let { it != null && it !is FirDefaultPropertyAccessor } -> false
            property.modality != Modality.FINAL -> {
                val dispatchReceiver = (originalFir as? FirQualifiedAccess)?.dispatchReceiver ?: return false
-                val propertyClassName = (this as FirPropertySymbol).let { it.overriddenSymbol ?: it }.callableId.classId
+                val propertyClassLookupTag = (this as FirPropertySymbol).let { it.overriddenSymbol ?: it }.dispatchReceiverClassOrNull()
                val receiverType = dispatchReceiver.typeRef.coneTypeSafe<ConeClassLikeType>()?.fullyExpandedType(session) ?: return false
                val receiverSymbol = receiverType.fullyExpandedType(session).lookupTag.toSymbol(session) ?: return false
-                val receiverClassName = receiverSymbol.classId
-                if (propertyClassName != receiverClassName) {
+                val receiverClassLookupTag = receiverSymbol.toLookupTag()
+                if (propertyClassLookupTag != receiverClassLookupTag) {
                    when (val receiverFir = receiverSymbol.fir) {
-                        is FirAnonymousObject -> true
-                        is FirRegularClass -> receiverFir.modality == Modality.FINAL
+                        is org.jetbrains.kotlin.fir.declarations.FirAnonymousObject -> true
+                        is org.jetbrains.kotlin.fir.declarations.FirRegularClass -> receiverFir.modality == Modality.FINAL
                        else -> throw IllegalStateException("Should not be here: $receiverFir")
                    }
                } else false
@@ -5,13 +5,11 @@

 package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve

-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.firProvider
@@ -245,7 +243,7 @@ private class ReturnTypeCalculatorWithJump(
        } else {
            val file = provider.getFirCallableContainerFile(symbol)

-            val outerClasses = generateSequence(id.classId) { classId ->
+            val outerClasses = generateSequence(symbol.containingClass()?.classId) { classId ->
                classId.outerClassId
            }.mapTo(mutableListOf()) { provider.getFirClassifierByFqName(it) }