[FIR] Rename containingClass function to containingClassLookupTag

Since this function returns lookup tag instead of FirClass or symbol
  the old name may lead to misunderstanding

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/FirDeserializedDeclarationSourceProvider.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.llFirMo
 import org.jetbrains.kotlin.analysis.project.structure.KtBuiltinsModule
 import org.jetbrains.kotlin.analysis.providers.createDeclarationProvider
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.unwrapFakeOverrides
 import org.jetbrains.kotlin.name.ClassId
@@ -125,7 +125,7 @@ internal object FirDeserializedDeclarationSourceProvider {
     }
 
     private fun FirCallableDeclaration.containingKtClass(project: Project): KtClassOrObject? =
-        unwrapFakeOverrides().containingClass()?.classId?.let { classByClassId(it, scope(project), project) }
+        unwrapFakeOverrides().containingClassLookupTag()?.classId?.let { classByClassId(it, scope(project), project) }
 
     private fun classByClassId(classId: ClassId, scope: GlobalSearchScope, project: Project): KtClassOrObject? {
         val correctedClassId = classIdMapping[classId] ?: classId

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/ConeTypeIdeRenderer.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.api.fir.renderer
 import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignation
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.containingClassForLocal
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isInner
@@ -213,7 +213,7 @@ internal class ConeTypeIdeRenderer(
     private fun collectDesignationPathForLocal(declaration: FirDeclaration): List<FirDeclaration>? {
         @OptIn(LookupTagInternals::class)
         val containingClass = when (declaration) {
-            is FirCallableDeclaration -> declaration.containingClass()?.toFirRegularClass(declaration.moduleData.session)
+            is FirCallableDeclaration -> declaration.containingClassLookupTag()?.toFirRegularClass(declaration.moduleData.session)
             is FirAnonymousObject -> return listOf(declaration)
             is FirClassLikeDeclaration -> declaration.let {
                 if (!declaration.isLocal) return null

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirIdeRendererBase.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.classKind
 import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.resolve.defaultType
@@ -76,7 +76,7 @@ internal abstract class FirIdeRendererBase(
     }
 
     private fun PrettyPrinter.renderVisibility(declaration: FirMemberDeclaration) {
-        if (declaration is FirConstructor && declaration.containingClass()?.toFirRegularClassSymbol(useSiteSession)?.isEnumClass == true) {
+        if (declaration is FirConstructor && declaration.containingClassLookupTag()?.toFirRegularClassSymbol(useSiteSession)?.isEnumClass == true) {
             return
         }
         val visibility = declaration.visibility

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirConstructorSymbol.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
 import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
@@ -52,7 +52,7 @@ internal class KtFirConstructorSymbol(
     override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
 
     override val containingClassIdIfNonLocal: ClassId?
-        get() = withValidityAssertion { firSymbol.containingClass()?.classId?.takeUnless { it.isLocal } }
+        get() = withValidityAssertion { firSymbol.containingClassLookupTag()?.classId?.takeUnless { it.isLocal } }
 
     override val isPrimary: Boolean get() = withValidityAssertion { firSymbol.isPrimary }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirEnumEntrySymbol.kt

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
@@ -47,7 +47,7 @@ internal class KtFirEnumEntrySymbol(
     override fun createPointer(): KtSymbolPointer<KtEnumEntrySymbol> = withValidityAssertion {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }
         return KtFirEnumEntrySymbolPointer(
-            firSymbol.containingClass()?.classId ?: error("Containing class should present for enum entry"),
+            firSymbol.containingClassLookupTag()?.classId ?: error("Containing class should present for enum entry"),
             firSymbol.name
         )
     }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirFunctionSymbol.kt

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -76,7 +76,7 @@ internal class KtFirFunctionSymbol(
         get() = withValidityAssertion {
             when {
                 firSymbol.isLocal -> KtSymbolKind.LOCAL
-                firSymbol.containingClass()?.classId == null -> KtSymbolKind.TOP_LEVEL
+                firSymbol.containingClassLookupTag()?.classId == null -> KtSymbolKind.TOP_LEVEL
                 else -> KtSymbolKind.CLASS_MEMBER
             }
         }
@@ -93,7 +93,7 @@ internal class KtFirFunctionSymbol(
 
             KtSymbolKind.CLASS_MEMBER ->
                 KtFirMemberFunctionSymbolPointer(
-                    firSymbol.containingClass()?.classId ?: error("ClassId should not be null for member function"),
+                    firSymbol.containingClassLookupTag()?.classId ?: error("ClassId should not be null for member function"),
                     firSymbol.name,
                     firSymbol.createSignature()
                 )

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirJavaFieldSymbol.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.utils.isStatic
 import org.jetbrains.kotlin.fir.declarations.utils.modalityOrFinal
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
@@ -53,7 +53,7 @@ internal class KtFirJavaFieldSymbol(
     override val isStatic: Boolean get() = withValidityAssertion { firSymbol.isStatic }
 
     override fun createPointer(): KtSymbolPointer<KtJavaFieldSymbol> = withValidityAssertion {
-        val containingClassId = firSymbol.containingClass()?.classId
+        val containingClassId = firSymbol.containingClassLookupTag()?.classId
             ?: error("Cannot find parent class for java field $callableIdIfNonLocal")
 
         return KtFirJavaFieldSymbolPointer(containingClassId, name)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt

@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.declarations.utils.*
@@ -71,7 +71,7 @@ internal class KtFirKotlinPropertySymbol(
 
     override val symbolKind: KtSymbolKind
         get() = withValidityAssertion {
-            when (firSymbol.containingClass()?.classId) {
+            when (firSymbol.containingClassLookupTag()?.classId) {
                 null -> KtSymbolKind.TOP_LEVEL
                 else -> KtSymbolKind.CLASS_MEMBER
             }
@@ -124,7 +124,7 @@ internal class KtFirKotlinPropertySymbol(
             KtSymbolKind.TOP_LEVEL -> TODO("Creating symbol for top level properties is not supported yet")
             KtSymbolKind.CLASS_MEMBER ->
                 KtFirMemberPropertySymbolPointer(
-                    firSymbol.containingClass()?.classId ?: error("ClassId should not be null for member property"),
+                    firSymbol.containingClassLookupTag()?.classId ?: error("ClassId should not be null for member property"),
                     firSymbol.name,
                     firSymbol.createSignature()
                 )

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirOverrideInfoProvider.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.fir.analysis.checkers.getImplementationStatus
 import org.jetbrains.kotlin.fir.analysis.checkers.isVisibleInClass
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
@@ -66,7 +66,7 @@ internal class KtFirOverrideInfoProvider(
         symbol.firSymbol.lazyResolveToPhase(FirResolvePhase.STATUS)
         val firDeclaration = symbol.firSymbol.fir as FirCallableDeclaration
         val containingClass =
-            getOriginalOverriddenSymbol(firDeclaration)?.containingClass()?.toSymbol(rootModuleSession) ?: return null
+            getOriginalOverriddenSymbol(firDeclaration)?.containingClassLookupTag()?.toSymbol(rootModuleSession) ?: return null
         return analysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(containingClass.fir.symbol) as? KtClassOrObjectSymbol
 
     }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.declarations.utils.isOverride
 import org.jetbrains.kotlin.fir.declarations.utils.isStatic
@@ -89,7 +89,7 @@ internal class KtFirSyntheticJavaPropertySymbol(
     override val origin: KtSymbolOrigin get() = withValidityAssertion { KtSymbolOrigin.JAVA_SYNTHETIC_PROPERTY }
 
     override fun createPointer(): KtSymbolPointer<KtSyntheticJavaPropertySymbol> = withValidityAssertion {
-        val containingClassId = firSymbol.containingClass()?.classId
+        val containingClassId = firSymbol.containingClassLookupTag()?.classId
             ?: error("Cannot find parent class for synthetic java property $callableIdIfNonLocal")
 
         return KtFirJavaSyntheticPropertySymbolPointer(containingClassId, name)

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDeclarationDesignation.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
@@ -64,7 +64,7 @@ private fun collectDesignationPath(declaration: FirDeclaration): List<FirDeclara
             if ((declaration as? FirCallableDeclaration)?.status?.visibility == Visibilities.Local) return null
             when (declaration) {
                 is FirSimpleFunction, is FirProperty, is FirField, is FirConstructor, is FirEnumEntry -> {
-                    val klass = declaration.containingClass() ?: return emptyList()
+                    val klass = declaration.containingClassLookupTag() ?: return emptyList()
                     if (klass.classId.isLocal) return null
                     klass.toFirRegularClassFromSameSession(declaration.moduleData.session)
                 }

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/FirJvmOverridesBackwardCompatibilityHelper.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
@@ -71,14 +71,14 @@ object FirJvmOverridesBackwardCompatibilityHelper : FirOverridesBackwardCompatib
         }
 
         if (!originalMember.isJavaOrEnhancement) return false
-        val containingClassName = originalMember.containingClass()?.classId?.asSingleFqName()?.toUnsafe() ?: return false
+        val containingClassName = originalMember.containingClassLookupTag()?.classId?.asSingleFqName()?.toUnsafe() ?: return false
         // If the super class is mapped to a Kotlin built-in class, then we don't require `override` keyword.
         if (JavaToKotlinClassMap.mapKotlinToJava(containingClassName) != null) {
             return true
         }
 
         if (!originalMember.isAbstract) {
-            val containingClass = originalMember.containingClass()?.toFirRegularClassSymbol(context.session)
+            val containingClass = originalMember.containingClassLookupTag()?.toFirRegularClassSymbol(context.session)
             if (containingClass?.isInterface == false) {
                 return false
             }

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmDefaultChecker.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
 import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isCompiledToJvmDefault
 import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isJvm6
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isInterface
 import org.jetbrains.kotlin.fir.declarations.utils.modality
@@ -127,7 +127,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
                 for (overriddenFunction in overriddenFunctions) {
                     val overriddenDeclarations = overriddenFunction.getOverriddenDeclarations()
                     for (overriddenDeclaration in overriddenDeclarations) {
-                        val containingClassSymbol = overriddenDeclaration.containingClass()?.toSymbol(context.session)
+                        val containingClassSymbol = overriddenDeclaration.containingClassLookupTag()?.toSymbol(context.session)
                         if (containingClassSymbol?.origin is FirDeclarationOrigin.Java &&
                             overriddenDeclaration.modality != Modality.ABSTRACT
                         ) {

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmExternalDeclarationChecker.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
 import org.jetbrains.kotlin.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isExternal
 import org.jetbrains.kotlin.fir.declarations.utils.isInline
@@ -63,7 +63,7 @@ object FirJvmExternalDeclarationChecker : FirBasicDeclarationChecker() {
             return
         }
 
-        val containingClassSymbol = declaration.symbol.containingClass()?.toFirRegularClassSymbol(context.session)
+        val containingClassSymbol = declaration.symbol.containingClassLookupTag()?.toFirRegularClassSymbol(context.session)
         if (containingClassSymbol != null) {
             if (containingClassSymbol.isInterface) {
                 reporter.reportOn(declaration.source, FirJvmErrors.EXTERNAL_DECLARATION_IN_INTERFACE, context)

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmFieldApplicabilityChecker.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.getContainingDeclarationSymbol
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
 import org.jetbrains.kotlin.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
@@ -41,7 +41,7 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
     override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
         val annotation = declaration.getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID) ?: return
         val session = context.session
-        val containingClassSymbol = declaration.containingClass()?.toFirRegularClassSymbol(session)
+        val containingClassSymbol = declaration.containingClassLookupTag()?.toFirRegularClassSymbol(session)
 
         val problem = when {
             declaration.delegate != null -> DELEGATE

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmInconsistentOperatorFromJavaCallChecker.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.overriddenFunctions
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
 import org.jetbrains.kotlin.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
 import org.jetbrains.kotlin.fir.expressions.toResolvedCallableSymbol
@@ -51,7 +51,7 @@ object FirJvmInconsistentOperatorFromJavaCallChecker : FirFunctionCallChecker()
             return true
         }
 
-        val containingClass = containingClass()?.toFirRegularClassSymbol(context.session) ?: return false
+        val containingClass = containingClassLookupTag()?.toFirRegularClassSymbol(context.session) ?: return false
         val overriddenFunctions = overriddenFunctions(containingClass, context)
         for (overriddenFunction in overriddenFunctions) {
             if (overriddenFunction is FirNamedFunctionSymbol && overriddenFunction.check(source, context, reporter)) {
@@ -61,4 +61,4 @@ object FirJvmInconsistentOperatorFromJavaCallChecker : FirFunctionCallChecker()
 
         return false
     }
-}
+}

compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameOverridesChecker.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
 import org.jetbrains.kotlin.fir.analysis.diagnostics.native.FirNativeErrors.INCOMPATIBLE_OBJC_NAME_OVERRIDE
 import org.jetbrains.kotlin.fir.analysis.native.checkers.FirNativeObjCNameChecker.getObjCNames
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.isIntersectionOverride
@@ -46,7 +46,7 @@ object FirNativeObjCNameOverridesChecker : FirClassChecker() {
         if (overriddenSymbols.isEmpty()) return
         val objCNames = overriddenSymbols.map { it.getFirstBaseSymbol(firTypeScope).getObjCNames() }
         if (!objCNames.allNamesEquals()) {
-            val containingDeclarations = overriddenSymbols.mapNotNull { it.containingClass()?.toFirRegularClassSymbol(context.session) }
+            val containingDeclarations = overriddenSymbols.mapNotNull { it.containingClassLookupTag()?.toFirRegularClassSymbol(context.session) }
             reporter.reportOn(
                 declarationToReport.source,
                 INCOMPATIBLE_OBJC_NAME_OVERRIDE,

compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementOverridesChecker.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
 import org.jetbrains.kotlin.fir.analysis.diagnostics.native.FirNativeErrors.INCOMPATIBLE_OBJC_REFINEMENT_OVERRIDE
 import org.jetbrains.kotlin.fir.analysis.native.checkers.FirNativeObjCRefinementChecker.hidesFromObjCClassId
 import org.jetbrains.kotlin.fir.analysis.native.checkers.FirNativeObjCRefinementChecker.refinesInSwiftClassId
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId
@@ -108,7 +108,7 @@ object FirNativeObjCRefinementOverridesChecker : FirClassChecker() {
         notRefinedSupers: List<FirCallableSymbol<*>>,
         context: CheckerContext
     ) {
-        val containingDeclarations = notRefinedSupers.mapNotNull { it.containingClass()?.toFirRegularClassSymbol(context.session) }
+        val containingDeclarations = notRefinedSupers.mapNotNull { it.containingClassLookupTag()?.toFirRegularClassSymbol(context.session) }
         if (annotations.isEmpty()) {
             reportOn(declaration.source, INCOMPATIBLE_OBJC_REFINEMENT_OVERRIDE, declaration.symbol, containingDeclarations, context)
         } else {

compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeThrowsChecker.kt

@@ -80,7 +80,7 @@ object FirNativeThrowsChecker : FirBasicDeclarationChecker() {
             reporter.reportOn(
                 declaration.source,
                 FirNativeErrors.INCOMPATIBLE_THROWS_INHERITED,
-                inherited.mapNotNull { it.key.containingClass()?.toFirRegularClassSymbol(context.session) },
+                inherited.mapNotNull { it.key.containingClassLookupTag()?.toFirRegularClassSymbol(context.session) },
                 context
             )
             return false
@@ -90,7 +90,7 @@ object FirNativeThrowsChecker : FirBasicDeclarationChecker() {
             ?: return true // Should not happen though.
 
         if (decodeThrowsFilter(throwsAnnotation, context.session) != overriddenThrows) {
-            val containingClassSymbol = overriddenMember.containingClass()?.toFirRegularClassSymbol(context.session)
+            val containingClassSymbol = overriddenMember.containingClassLookupTag()?.toFirRegularClassSymbol(context.session)
             if (containingClassSymbol != null) {
                 reporter.reportOn(throwsAnnotation?.source, FirNativeErrors.INCOMPATIBLE_THROWS_OVERRIDE, containingClassSymbol, context)
             }
@@ -110,7 +110,7 @@ object FirNativeThrowsChecker : FirBasicDeclarationChecker() {
 
         fun getInheritedThrows(localThrowsAnnotation: FirAnnotationCall?, localFunctionSymbol: FirNamedFunctionSymbol) {
             if (!visited.add(localFunctionSymbol)) return
-            val containingClassSymbol = localFunctionSymbol.containingClass()?.toFirRegularClassSymbol(context.session)
+            val containingClassSymbol = localFunctionSymbol.containingClassLookupTag()?.toFirRegularClassSymbol(context.session)
 
             if (containingClassSymbol != null) {
                 val unsubstitutedScope = containingClassSymbol.unsubstitutedScope(context)
@@ -181,4 +181,4 @@ object FirNativeThrowsChecker : FirBasicDeclarationChecker() {
     }
 
     private data class ThrowsFilter(val classes: Set<ConeKotlinType>?)
-}
+}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.getChild
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.containingClassForLocalAttr
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
@@ -109,7 +109,7 @@ fun FirTypeRef.toRegularClassSymbol(session: FirSession): FirRegularClassSymbol?
  * or null if no proper declaration has been found.
  */
 fun FirDeclaration.getContainingClassSymbol(session: FirSession): FirClassLikeSymbol<*>? =
-    (this as? FirCallableDeclaration)?.containingClass()?.toSymbol(session)
+    (this as? FirCallableDeclaration)?.containingClassLookupTag()?.toSymbol(session)
 
 @OptIn(SymbolInternals::class)
 fun FirBasedSymbol<*>.getContainingClassSymbol(session: FirSession): FirClassLikeSymbol<*>? = fir.getContainingClassSymbol(session)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.checkers.getModifier
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.expressions.*
@@ -324,7 +324,7 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() {
         }
 
         private fun FirCallableSymbol<*>.isInsidePrivateClass(): Boolean {
-            val containingClassSymbol = this.containingClass()?.toSymbol(session) ?: return false
+            val containingClassSymbol = this.containingClassLookupTag()?.toSymbol(session) ?: return false
 
             val containingClassVisibility = when (containingClassSymbol) {
                 is FirAnonymousObjectSymbol -> return false
@@ -426,7 +426,7 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() {
 
     private fun FirCallableDeclaration.getOverriddenSymbols(context: CheckerContext): List<FirCallableSymbol<out FirCallableDeclaration>> {
         if (!this.isOverride) return emptyList()
-        val classSymbol = this.containingClass()?.toSymbol(context.session) as? FirClassSymbol<*> ?: return emptyList()
+        val classSymbol = this.containingClassLookupTag()?.toSymbol(context.session) as? FirClassSymbol<*> ?: return emptyList()
         val scope = classSymbol.unsubstitutedScope(context)
         //this call is needed because AbstractFirUseSiteMemberScope collect overrides in it only,
         //and not in processDirectOverriddenFunctionsWithBaseScope
@@ -455,7 +455,7 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() {
         context: CheckerContext,
         reporter: DiagnosticReporter
     ): Boolean {
-        if (declaration.containingClass() == null) return true
+        if (declaration.containingClassLookupTag() == null) return true
         if (effectiveVisibility == EffectiveVisibility.PrivateInClass) return true
 
         if (!declaration.isFinal) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirNotImplementedOverrideChecker.kt

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MANY_IMPL_MEMBER_
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OVERRIDING_FINAL_MEMBER_BY_DELEGATION
 import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.*
@@ -149,13 +149,13 @@ object FirNotImplementedOverrideChecker : FirClassChecker() {
                     it.modality == Modality.ABSTRACT
                 }
             if (implIntersections.any {
-                    (it.containingClass()?.toSymbol(context.session) as? FirRegularClassSymbol)?.classKind == ClassKind.CLASS
+                    (it.containingClassLookupTag()?.toSymbol(context.session) as? FirRegularClassSymbol)?.classKind == ClassKind.CLASS
                 }
             ) {
                 reporter.reportOn(source, MANY_IMPL_MEMBER_NOT_IMPLEMENTED, classSymbol, notImplementedIntersectionSymbol, context)
             } else {
                 if (canHaveAbstractDeclarations && abstractIntersections.any {
-                        (it.containingClass()?.toSymbol(context.session) as? FirRegularClassSymbol)?.classKind == ClassKind.CLASS
+                        (it.containingClassLookupTag()?.toSymbol(context.session) as? FirRegularClassSymbol)?.classKind == ClassKind.CLASS
                     }
                 ) {
                     return

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOperatorModifierChecker.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.overriddenFunctions
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.declarations.utils.isOperator
@@ -188,11 +188,11 @@ private object OperatorFunctionChecks {
             member,
             object : Check {
                 override fun check(context: CheckerContext, function: FirSimpleFunction): String? {
-                    val containingClassSymbol = function.containingClass()?.toFirRegularClassSymbol(context.session) ?: return null
+                    val containingClassSymbol = function.containingClassLookupTag()?.toFirRegularClassSymbol(context.session) ?: return null
                     val customEqualsSupported = context.languageVersionSettings.supportsFeature(LanguageFeature.CustomEqualsInInlineClasses)
 
                     if (function.overriddenFunctions(containingClassSymbol, context)
-                            .any { it.containingClass()?.classId == StandardClassIds.Any }
+                            .any { it.containingClassLookupTag()?.classId == StandardClassIds.Any }
                         || (customEqualsSupported && function.isTypedEqualsInInlineClass(context.session))
                     ) {
                         return null

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirOptInUsageBaseCh
 import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.overridesBackwardCompatibilityHelper
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isFinal
 import org.jetbrains.kotlin.fir.declarations.utils.isOverride
@@ -285,7 +285,7 @@ object FirOverrideChecker : FirClassChecker() {
                     skipCheckForContainingClassVisibility = true
                 )
             }?.originalOrSelf() ?: return
-            val originalContainingClassSymbol = overridden.containingClass()?.toSymbol(context.session) as? FirRegularClassSymbol ?: return
+            val originalContainingClassSymbol = overridden.containingClassLookupTag()?.toSymbol(context.session) as? FirRegularClassSymbol ?: return
             reporter.reportOn(
                 member.source,
                 FirErrors.VIRTUAL_MEMBER_HIDDEN,
@@ -369,7 +369,7 @@ object FirOverrideChecker : FirClassChecker() {
         overridden: FirCallableSymbol<*>,
         context: CheckerContext
     ) {
-        overridden.containingClass()?.let { containingClass ->
+        overridden.containingClassLookupTag()?.let { containingClass ->
             reportOn(overriding.source, FirErrors.OVERRIDING_FINAL_MEMBER, overridden, containingClass.name, context)
         }
     }
@@ -387,7 +387,7 @@ object FirOverrideChecker : FirClassChecker() {
         overridden: FirCallableSymbol<*>,
         context: CheckerContext
     ) {
-        val containingClass = overridden.containingClass() ?: return
+        val containingClass = overridden.containingClassLookupTag() ?: return
         reportOn(
             overriding.source,
             FirErrors.CANNOT_WEAKEN_ACCESS_PRIVILEGE,
@@ -403,7 +403,7 @@ object FirOverrideChecker : FirClassChecker() {
         overridden: FirCallableSymbol<*>,
         context: CheckerContext
     ) {
-        val containingClass = overridden.containingClass() ?: return
+        val containingClass = overridden.containingClassLookupTag() ?: return
         reportOn(
             overriding.source,
             FirErrors.CANNOT_CHANGE_ACCESS_PRIVILEGE,

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/declarationUtils.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.hasModifier
 import org.jetbrains.kotlin.fir.analysis.checkers.modality
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.containingClassForStaticMemberAttr
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
@@ -120,7 +120,7 @@ fun FirClassSymbol<*>.primaryConstructorSymbol(): FirConstructorSymbol? {
 }
 
 fun FirSimpleFunction.isTypedEqualsInInlineClass(session: FirSession): Boolean =
-    containingClass()?.toFirRegularClassSymbol(session)?.run {
+    containingClassLookupTag()?.toFirRegularClassSymbol(session)?.run {
         with(this@isTypedEqualsInInlineClass) {
             contextReceivers.isEmpty() && receiverTypeRef == null && name == OperatorNameConventions.EQUALS
                     && this@run.isInline && valueParameters.size == 1 && returnTypeRef.isBoolean

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAbstractSuperCallChecker.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.context.findClosest
 import org.jetbrains.kotlin.fir.analysis.checkers.explicitReceiverIsNotSuperReference
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.isAbstract
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
@@ -35,7 +35,7 @@ object FirAbstractSuperCallChecker : FirQualifiedAccessExpressionChecker() {
             // handles all the FirSimpleFunction/FirProperty/etc.
             val declarationSymbol = expression.toResolvedCallableSymbol() ?: return
 
-            val containingClassSymbol = declarationSymbol.containingClass()?.toSymbol(context.session) as? FirRegularClassSymbol ?: return
+            val containingClassSymbol = declarationSymbol.containingClassLookupTag()?.toSymbol(context.session) as? FirRegularClassSymbol ?: return
 
             if (containingClassSymbol.isAbstract) {
                 if (declarationSymbol.isAbstract) {
@@ -43,7 +43,7 @@ object FirAbstractSuperCallChecker : FirQualifiedAccessExpressionChecker() {
                 }
                 if (declarationSymbol is FirIntersectionCallableSymbol) {
                     val symbolFromBaseClass = declarationSymbol.intersections.firstOrNull {
-                        it.containingClass()?.toSymbol(context.session)?.classKind != ClassKind.INTERFACE
+                        it.containingClassLookupTag()?.toSymbol(context.session)?.classKind != ClassKind.INTERFACE
                     }
                     if (symbolFromBaseClass?.isAbstract == true) {
                         if (context.languageVersionSettings.supportsFeature(LanguageFeature.ForbidSuperDelegationToAbstractFakeOverride)) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt

@@ -152,7 +152,7 @@ object FirOptInUsageBaseChecker {
         val result = knownExperimentalities ?: SmartSet.create()
         val session = context.session
         if (fir is FirCallableDeclaration) {
-            val parentClassSymbol = fir.containingClass()?.toSymbol(session) as? FirRegularClassSymbol
+            val parentClassSymbol = fir.containingClassLookupTag()?.toSymbol(session) as? FirRegularClassSymbol
             if (fir.isSubstitutionOrIntersectionOverride) {
                 parentClassSymbol?.lazyResolveToPhase(FirResolvePhase.STATUS)
                 val parentClassScope = parentClassSymbol?.unsubstitutedScope(context)

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.serialization.constant
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationArgumentMapping
@@ -98,7 +98,7 @@ internal object FirToConstantValueTransformer : FirDefaultVisitor<ConstantValue<
 
             symbol is FirConstructorSymbol -> {
                 val constructorCall = qualifiedAccessExpression as FirFunctionCall
-                val constructedClassSymbol = symbol.containingClass()?.toFirRegularClassSymbol(data) ?: return null
+                val constructedClassSymbol = symbol.containingClassLookupTag()?.toFirRegularClassSymbol(data) ?: return null
                 return if (constructedClassSymbol.classKind == ClassKind.ANNOTATION_CLASS) {
                     AnnotationValue(
                         buildAnnotationCall {

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmMangleComputer.kt

@@ -85,7 +85,7 @@ open class FirJvmMangleComputer(
 
     private fun FirDeclaration.visitParent() {
         val (parentPackageFqName, parentClassId) = when (this) {
-            is FirCallableDeclaration -> this.containingClass()?.classId?.let { it.packageFqName to it } ?: return
+            is FirCallableDeclaration -> this.containingClassLookupTag()?.classId?.let { it.packageFqName to it } ?: return
             is FirClassLikeDeclaration -> this.symbol.classId.let { it.packageFqName to it.outerClassId }
             else -> return
         }

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

@@ -229,7 +229,7 @@ private fun FirCallableSymbol<*>.toSymbolForCall(
 ): IrSymbol? {
     val dispatchReceiverLookupTag = when {
         dispatchReceiver is FirNoReceiverExpression -> {
-            val containingClass = containingClass()
+            val containingClass = containingClassLookupTag()
             if (containingClass != null && containingClass.classId != StandardClassIds.Any) {
                 // Make sure that symbol is not extension and is not from inline class
                 val coneType = ((explicitReceiver as? FirResolvedQualifier)?.symbol as? FirClassSymbol)?.defaultType()
@@ -367,7 +367,7 @@ internal tailrec fun FirCallableSymbol<*>.unwrapCallRepresentative(root: FirCall
     }
 
     val overriddenSymbol = fir.originalForSubstitutionOverride?.takeIf {
-        it.containingClass() == root.containingClass()
+        it.containingClassLookupTag() == root.containingClassLookupTag()
     }?.symbol ?: return this
 
     return overriddenSymbol.unwrapCallRepresentative(this)

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

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.backend
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression
@@ -471,7 +471,7 @@ class Fir2IrClassifierStorage(
     ): IrEnumEntry {
         getCachedIrEnumEntry(enumEntry)?.let { return it }
         val containingFile = firProvider.getFirCallableContainerFile(enumEntry.symbol)
-        val irParentClass = irParent ?: enumEntry.containingClass()?.let { findIrClass(it) }
+        val irParentClass = irParent ?: enumEntry.containingClassLookupTag()?.let { findIrClass(it) }
 
         @Suppress("NAME_SHADOWING")
         val predefinedOrigin = predefinedOrigin ?: if (containingFile != null) {

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

@@ -265,7 +265,7 @@ class Fir2IrDeclarationStorage(
         val firBasedSymbol = callableDeclaration.symbol
         val callableId = firBasedSymbol.callableId
         val callableOrigin = callableDeclaration.origin
-        return findIrParent(callableId.packageName, callableDeclaration.containingClass(), firBasedSymbol, callableOrigin)
+        return findIrParent(callableId.packageName, callableDeclaration.containingClassLookupTag(), firBasedSymbol, callableOrigin)
     }
 
     private fun IrDeclaration.setAndModifyParent(irParent: IrDeclarationParent?) {
@@ -470,7 +470,7 @@ class Fir2IrDeclarationStorage(
         return createIrFunction(
             function,
             irParent,
-            containingClass = function.containingClass(),
+            containingClass = function.containingClassLookupTag(),
             isLocal = isLocal,
             forceTopLevelPrivate = forceTopLevelPrivate
         )
@@ -973,7 +973,7 @@ class Fir2IrDeclarationStorage(
         signatureCalculator: () -> IdSignature?,
         referenceIfAny: (IdSignature) -> IC?
     ): IC? {
-        val isFakeOverride = dispatchReceiverLookupTag != null && dispatchReceiverLookupTag != declaration.containingClass()
+        val isFakeOverride = dispatchReceiverLookupTag != null && dispatchReceiverLookupTag != declaration.containingClassLookupTag()
         if (!isFakeOverride) {
             cache[declaration]?.let { return it }
         }
@@ -1277,7 +1277,7 @@ class Fir2IrDeclarationStorage(
                 createIrFunction(fir, irParent, predefinedOrigin = declarationOrigin).symbol
             }
             is FirSimpleFunction -> {
-                val unmatchedReceiver = dispatchReceiverLookupTag != firFunctionSymbol.containingClass()
+                val unmatchedReceiver = dispatchReceiverLookupTag != firFunctionSymbol.containingClassLookupTag()
                 if (unmatchedReceiver) {
                     generateLazyFakeOverrides(fir.name, dispatchReceiverLookupTag)
                 }
@@ -1345,7 +1345,7 @@ class Fir2IrDeclarationStorage(
         if (fir.isLocal) {
             return localStorage.getDelegatedProperty(fir)?.symbol ?: getIrVariableSymbol(fir)
         }
-        val containingClassLookupTag = firPropertySymbol.containingClass()
+        val containingClassLookupTag = firPropertySymbol.containingClassLookupTag()
         val unmatchedReceiver = dispatchReceiverLookupTag != containingClassLookupTag
         if (unmatchedReceiver) {
             generateLazyFakeOverrides(fir.name, dispatchReceiverLookupTag)
@@ -1561,7 +1561,7 @@ class Fir2IrDeclarationStorage(
             is FirEnumEntry -> {
                 classifierStorage.getCachedIrEnumEntry(firDeclaration)?.let { return it.symbol }
                 val containingFile = firProvider.getFirCallableContainerFile(firVariableSymbol)
-                val irParentClass = firDeclaration.containingClass()?.let { classifierStorage.findIrClass(it) }
+                val irParentClass = firDeclaration.containingClassLookupTag()?.let { classifierStorage.findIrClass(it) }
                 classifierStorage.createIrEnumEntry(
                     firDeclaration,
                     irParent = irParentClass,

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/FakeOverrideGenerator.kt

@@ -383,7 +383,7 @@ class FakeOverrideGenerator(
         irProducer: (F) -> S
     ): List<S> {
         val overriddenContainingClass =
-            overridden.containingClass()?.toSymbol(session)?.fir as? FirClass ?: return emptyList()
+            overridden.containingClassLookupTag()?.toSymbol(session)?.fir as? FirClass ?: return emptyList()
 
         val overriddenContainingIrClass =
             declarationStorage.classifierStorage.getIrClassSymbol(overriddenContainingClass.symbol).owner as? IrClass

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt

@@ -127,7 +127,7 @@ class FirBasedSignatureComposer(override val mangler: FirMangler) : Fir2IrSignat
                 )
             }
             is FirCallableDeclaration -> {
-                val classId = containingClassId ?: declaration.containingClass()?.classId
+                val classId = containingClassId ?: declaration.containingClassLookupTag()?.classId
                 val packageName = classId?.packageFqName ?: declaration.symbol.callableId.packageName
                 val callableName = declaration.irName
 

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

@@ -220,7 +220,7 @@ class JavaClassUseSiteMemberScope(
     private fun FirPropertySymbol.getBuiltinSpecialPropertyGetterName(): Name? {
         var result: Name? = null
         superTypeScopes.processOverriddenPropertiesAndSelf(this) { overridden ->
-            val fqName = overridden.fir.containingClass()?.classId?.asSingleFqName()?.child(overridden.fir.name)
+            val fqName = overridden.fir.containingClassLookupTag()?.classId?.asSingleFqName()?.child(overridden.fir.name)
 
             BuiltinSpecialProperties.PROPERTY_FQ_NAME_TO_JVM_GETTER_NAME_MAP[fqName]?.let { name ->
                 result = name

compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.resolve.calls.jvm
 
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isExpect
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
@@ -35,10 +35,10 @@ class ConeEquivalentCallConflictResolver(
         val result = mutableSetOf<Candidate>()
         outerLoop@ for (myCandidate in candidates) {
             val me = myCandidate.symbol.fir
-            if (me is FirCallableDeclaration && me.symbol.containingClass() == null) {
+            if (me is FirCallableDeclaration && me.symbol.containingClassLookupTag() == null) {
                 for (otherCandidate in result) {
                     val other = otherCandidate.symbol.fir
-                    if (other is FirCallableDeclaration && other.symbol.containingClass() == null) {
+                    if (other is FirCallableDeclaration && other.symbol.containingClassLookupTag() == null) {
                         if (areEquivalentTopLevelCallables(me, myCandidate, other, otherCandidate)) {
                             continue@outerLoop
                         }

compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmPlatformOverloadsConflictResolver.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.calls.jvm
 
 import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirField
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.languageVersionSettings
@@ -33,10 +33,10 @@ class JvmPlatformOverloadsConflictResolver(
         val result = mutableSetOf<Candidate>()
         outerLoop@ for (myCandidate in candidates) {
             val me = myCandidate.symbol.fir
-            if (me is FirProperty && me.symbol.containingClass() != null) {
+            if (me is FirProperty && me.symbol.containingClassLookupTag() != null) {
                 for (otherCandidate in candidates) {
                     val other = otherCandidate.symbol.fir
-                    if (other is FirField && other.symbol.containingClass() != null) {
+                    if (other is FirField && other.symbol.containingClassLookupTag() != null) {
                         // NB: FE 1.0 does class equivalence check here
                         // However, in FIR container classes aren't the same for our samples (see fieldPropertyOverloads.kt)
                         // E.g. we can have SomeConcreteJavaEnum for field and kotlin.Enum for static property 'name'
@@ -48,4 +48,4 @@ class JvmPlatformOverloadsConflictResolver(
         }
         return result
     }
-}
+}

compiler/fir/java/src/org/jetbrains/kotlin/fir/scopes/jvm/SignatureUtils.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.scopes.jvm
 
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.StandardClassIds
 
 fun FirFunction.computeJvmSignature(typeConversion: (FirTypeRef) -> ConeKotlinType? = FirTypeRef::coneTypeSafe): String? {
-    val containingClass = containingClass() ?: return null
+    val containingClass = containingClassLookupTag() ?: return null
 
     return SignatureBuildingComponents.signature(containingClass.classId, computeJvmDescriptor(typeConversion = typeConversion))
 }

compiler/fir/providers/src/org/jetbrains/kotlin/fir/FirVisibilityChecker.kt

@@ -154,7 +154,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
                     }
                 }
 
-                val containingLookupTag = this.containingClass()
+                val containingLookupTag = this.containingClassLookupTag()
                 val containingClass = containingLookupTag?.toSymbol(session)?.fir
 
                 if (isStatic && containingClass != null) {
@@ -521,7 +521,7 @@ fun FirBasedSymbol<*>.getOwnerLookupTag(): ConeClassLikeLookupTag? {
     return when (this) {
         is FirBackingFieldSymbol -> fir.propertySymbol.getOwnerLookupTag()
         is FirClassLikeSymbol<*> -> getContainingClassLookupTag()
-        is FirCallableSymbol<*> -> containingClass()
+        is FirCallableSymbol<*> -> containingClassLookupTag()
         else -> error("Unsupported owner search for ${fir.javaClass}: ${fir.render()}")
     }
 }

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

@@ -502,7 +502,7 @@ private fun initialTypeOfCandidate(candidate: Candidate, typeRef: FirResolvedTyp
 }
 
 fun FirCallableDeclaration.getContainingClass(session: FirSession): FirRegularClass? =
-    this.containingClass()?.let { lookupTag ->
+    this.containingClassLookupTag()?.let { lookupTag ->
         session.symbolProvider.getSymbolByLookupTag(lookupTag)?.fir as? FirRegularClass
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt

@@ -293,7 +293,7 @@ private class ReturnTypeCalculatorWithJump(
             val provider = session.firProvider
             val file = provider.getFirCallableContainerFile(symbol)
 
-            val outerClasses = generateSequence(symbol.containingClass()?.classId) { classId ->
+            val outerClasses = generateSequence(symbol.containingClassLookupTag()?.classId) { classId ->
                 classId.outerClassId
             }.mapTo(mutableListOf()) { provider.getFirClassifierByFqName(it) }
 

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

@@ -25,8 +25,8 @@ fun FirCallableDeclaration.dispatchReceiverClassOrNull(): ConeClassLikeLookupTag
     return (dispatchReceiverType as? ConeClassLikeType)?.lookupTag
 }
 
-fun FirCallableSymbol<*>.containingClass(): ConeClassLikeLookupTag? = fir.containingClass()
+fun FirCallableSymbol<*>.containingClassLookupTag(): ConeClassLikeLookupTag? = fir.containingClassLookupTag()
-fun FirCallableDeclaration.containingClass(): ConeClassLikeLookupTag? {
+fun FirCallableDeclaration.containingClassLookupTag(): ConeClassLikeLookupTag? {
     return (containingClassForStaticMemberAttr ?: dispatchReceiverClassOrNull())
 }
 

plugins/sam-with-receiver/sam-with-receiver.k2/src/org/jetbrains/kotlin/samWithReceiver/k2/FirSamWithReceiverConventionTransformer.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.samWithReceiver.k2
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.utils.isSuspend
 import org.jetbrains.kotlin.fir.resolve.FirSamConversionTransformerExtension
@@ -21,7 +21,7 @@ class FirSamWithReceiverConventionTransformer(
     session: FirSession
 ) : FirSamConversionTransformerExtension(session) {
     override fun getCustomFunctionalTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? {
-        val containingClassSymbol = function.containingClass()?.toFirRegularClassSymbol(session) ?: return null
+        val containingClassSymbol = function.containingClassLookupTag()?.toFirRegularClassSymbol(session) ?: return null
         return runIf(containingClassSymbol.resolvedAnnotationClassIds.any { it.asSingleFqName().asString() in annotations }) {
             val parameterTypes = function.valueParameters.map { it.returnTypeRef.coneType }
             if (parameterTypes.isEmpty()) return null