[Analysis API] rework containing declaration provider

now it should work for non-source declarations

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolContainingDeclarationProvider.kt

@@ -11,22 +11,19 @@ import com.intellij.psi.search.ProjectScope
 import org.jetbrains.kotlin.analysis.api.components.KtSymbolContainingDeclarationProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getDescriptor
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.symbols.KtBackingFieldSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtDeclarationSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule
 import org.jetbrains.kotlin.analysis.project.structure.KtLibrarySourceModule
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
-import org.jetbrains.kotlin.cfg.getElementParentDeclaration
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.load.kotlin.JvmPackagePartSource
 import org.jetbrains.kotlin.platform.TargetPlatform
@@ -43,27 +40,14 @@ internal class KtFe10SymbolContainingDeclarationProvider(
     override val token: KtLifetimeToken
         get() = analysisSession.token
 
-    override fun getContainingDeclaration(symbol: KtSymbol): KtSymbolWithKind? {
+    override fun getContainingDeclaration(symbol: KtSymbol): KtDeclarationSymbol? {
         if (symbol is KtSymbolWithKind && symbol.symbolKind == KtSymbolKind.TOP_LEVEL) {
             return null
         }
 
         return when (symbol) {
-            is KtPackageSymbol -> null
             is KtBackingFieldSymbol -> symbol.owningProperty
-            is KtFe10DescSymbol<*> -> symbol.descriptor.containingDeclaration?.toKtSymbol(analysisContext) as? KtSymbolWithKind
-            is KtFe10PsiSymbol<*, *> -> {
-                val parentDeclaration = symbol.psi.getElementParentDeclaration()
-                if (parentDeclaration != null) {
-                    return with(analysisSession) {
-                        parentDeclaration.getSymbol() as? KtSymbolWithKind
-                    }
-                }
-
-                return null
-            }
-
-            else -> null
+            else -> symbol.getDescriptor()?.containingDeclaration?.toKtSymbol(analysisContext) as? KtDeclarationSymbol
         }
     }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolContainingDeclarationProvider.kt

@@ -10,55 +10,64 @@ import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.analysis.api.components.KtSymbolContainingDeclarationProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
-import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirReceiverParameterSymbol
-import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
-import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.fir.utils.firSymbol
 import org.jetbrains.kotlin.analysis.api.fir.utils.getContainingKtModule
 import org.jetbrains.kotlin.analysis.api.fir.utils.withSymbolAttachment
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
+import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
 import org.jetbrains.kotlin.analysis.utils.printer.parentOfType
+import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
+import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
 
 internal class KtFirSymbolContainingDeclarationProvider(
     override val analysisSession: KtFirAnalysisSession,
     override val token: KtLifetimeToken
 ) : KtSymbolContainingDeclarationProvider(), KtFirAnalysisSessionComponent {
-    override fun getContainingDeclaration(symbol: KtSymbol): KtSymbolWithKind? { if (symbol is KtReceiverParameterSymbol) {
-            return firSymbolBuilder.buildSymbol((symbol as KtFirReceiverParameterSymbol).firSymbol) as KtSymbolWithKind
-        }
-
-        if (symbol is KtPackageSymbol) return null
+    override fun getContainingDeclaration(symbol: KtSymbol): KtDeclarationSymbol? {
+        if (symbol !is KtDeclarationSymbol) return null
         if (symbol is KtSymbolWithKind && symbol.symbolKind == KtSymbolKind.TOP_LEVEL) return null
-        if (symbol is KtCallableSymbol) {
-            val classId = symbol.callableIdIfNonLocal?.classId
-            if (classId != null) {
-                with(analysisSession) {
-                    return getClassOrObjectSymbolByClassId(classId)
-                }
-            }
-        }
+        fun getParentSymbolByPsi() = getContainingPsi(symbol).let { with(analysisSession) { it.getSymbol() } }
         return when (symbol) {
-            is KtFirTypeParameterSymbol -> {
-                firSymbolBuilder.buildSymbol(symbol.firSymbol.containingDeclarationSymbol) as KtSymbolWithKind
+            is KtPropertyAccessorSymbol -> firSymbolBuilder.buildSymbol(symbol.firSymbol.fir.propertySymbol) as? KtDeclarationSymbol
+            is KtBackingFieldSymbol -> symbol.owningProperty
+            is KtTypeParameterSymbol -> firSymbolBuilder.buildSymbol(symbol.firSymbol.containingDeclarationSymbol) as? KtDeclarationSymbol
+            is KtLocalVariableSymbol -> getParentSymbolByPsi()
+            is KtAnonymousFunctionSymbol -> getParentSymbolByPsi()
+            is KtAnonymousObjectSymbol -> getParentSymbolByPsi()
+            is KtSamConstructorSymbol -> null // SAM constructors are always toplevel
+
+            is KtClassInitializerSymbol -> {
+                val outerFirClassifier = symbol.firSymbol.getContainingClassSymbol(symbol.firSymbol.llFirSession)
+                    ?: return getParentSymbolByPsi()
+                firSymbolBuilder.buildSymbol(outerFirClassifier) as? KtDeclarationSymbol
             }
-            is KtSymbolWithKind -> when (symbol.origin) {
-                KtSymbolOrigin.SOURCE, KtSymbolOrigin.SOURCE_MEMBER_GENERATED ->
-                    getContainingDeclarationForKotlinInSourceSymbol(symbol)
-                KtSymbolOrigin.LIBRARY, KtSymbolOrigin.JAVA, KtSymbolOrigin.JAVA_SYNTHETIC_PROPERTY ->
-                    getContainingDeclarationForLibrarySymbol(symbol)
-                KtSymbolOrigin.PROPERTY_BACKING_FIELD -> getContainingDeclarationForBackingFieldSymbol(symbol)
-                KtSymbolOrigin.INTERSECTION_OVERRIDE, KtSymbolOrigin.SUBSTITUTION_OVERRIDE -> TODO()
-                KtSymbolOrigin.SAM_CONSTRUCTOR -> null
-                KtSymbolOrigin.PLUGIN -> TODO("Containing declaration is requested for ${ DebugSymbolRenderer.render(symbol) }")
-                KtSymbolOrigin.DELEGATED -> TODO()
+
+            is KtValueParameterSymbol -> {
+                // todo that does not work for parameters not from source, corresponding info should be added to the fir tree
+                getParentSymbolByPsi()
             }
-            else -> null
+
+            is KtCallableSymbol -> {
+                val outerFirClassifier = symbol.firSymbol.getContainingClassSymbol(symbol.firSymbol.llFirSession)
+                    ?: return getParentSymbolByPsi()
+                firSymbolBuilder.buildSymbol(outerFirClassifier) as? KtDeclarationSymbol
+            }
+
+            is KtClassLikeSymbol -> {
+                val classId = symbol.classIdIfNonLocal ?: return getParentSymbolByPsi() // local
+                val outerClassId = classId.outerClassId ?: return null // toplevel
+                val outerFirClassifier = symbol.firSymbol.llFirSession.firProvider.getFirClassifierByFqName(outerClassId) ?: return null
+                firSymbolBuilder.buildSymbol(outerFirClassifier) as? KtDeclarationSymbol
+            }
+
+
         }
     }
 
@@ -66,25 +75,8 @@ internal class KtFirSymbolContainingDeclarationProvider(
         return symbol.getContainingKtModule(analysisSession.firResolveSession)
     }
 
-    private fun getContainingDeclarationForBackingFieldSymbol(symbol: KtSymbolWithKind): KtSymbolWithKind {
-        require(symbol is KtBackingFieldSymbol)
-        return symbol.owningProperty
-    }
 
-    private fun getContainingDeclarationForKotlinInSourceSymbol(symbol: KtSymbolWithKind): KtSymbolWithKind = with(analysisSession) {
-        require(symbol.origin == KtSymbolOrigin.SOURCE || symbol.origin == KtSymbolOrigin.SOURCE_MEMBER_GENERATED)
-        require(symbol is KtFirSymbol<*>)
-
-        val containingDeclaration = getContainingPsi(symbol)
-
-        return with(analysisSession) {
-            val containingSymbol = containingDeclaration.getSymbol()
-            check(containingSymbol is KtSymbolWithKind)
-            containingSymbol
-        }
-    }
-
-    private fun getContainingPsi(symbol: KtFirSymbol<*>): KtDeclaration {
+    private fun getContainingPsi(symbol: KtSymbol): KtDeclaration {
         val source = symbol.firSymbol.source
         val thisSource = when (source?.kind) {
             null -> buildErrorWithAttachment("PSI should present for declaration built by Kotlin code") {
@@ -106,12 +98,12 @@ internal class KtFirSymbolContainingDeclarationProvider(
 
         return when (symbol.origin) {
             KtSymbolOrigin.SOURCE -> thisSource.getContainingKtDeclaration()
-                ?: buildErrorWithAttachment("Containing declaration should present for non-toplevel declaration") {
+                ?: buildErrorWithAttachment("Containing declaration should present for non-toplevel declaration ${thisSource::class}") {
                     withSymbolAttachment("symbolForContainingPsi", symbol)
                 }
 
             KtSymbolOrigin.SOURCE_MEMBER_GENERATED -> thisSource as KtDeclaration
-            else -> buildErrorWithAttachment("Unsupported declaration origin ${symbol.origin}") {
+            else -> buildErrorWithAttachment("Unsupported declaration origin ${symbol.origin} ${thisSource::class}") {
                 withSymbolAttachment("symbolForContainingPsi", symbol)
             }
         }
@@ -122,45 +114,4 @@ internal class KtFirSymbolContainingDeclarationProvider(
             is KtDestructuringDeclaration -> container.parentOfType()
             else -> container
         }
-
-    private fun getContainingDeclarationForLibrarySymbol(symbol: KtSymbolWithKind): KtSymbolWithKind = with(analysisSession) {
-        require(symbol.origin == KtSymbolOrigin.LIBRARY || symbol.origin == KtSymbolOrigin.JAVA)
-        check(symbol.symbolKind == KtSymbolKind.CLASS_MEMBER)
-
-        fun error(message: String): Nothing {
-            buildErrorWithAttachment(message) {
-                withSymbolAttachment("symbolToGetContaining", symbol)
-            }
-        }
-
-        val containingClassId = when (symbol) {
-            is KtClassLikeSymbol -> {
-                val classId = symbol.classIdIfNonLocal
-                    ?: error("classId should not be null for non-local declaration")
-                classId.outerClassId
-            }
-            is KtFunctionSymbol -> {
-                val fqName = symbol.callableIdIfNonLocal
-                    ?: error("callableIdIfNonLocal should not be null for non-local declaration")
-                fqName.classId
-            }
-            is KtEnumEntrySymbol -> {
-                val classId = symbol.containingEnumClassIdIfNonLocal
-                    ?: error("fqName should not be null for non-local declaration")
-                classId.outerClassId
-            }
-            is KtPropertySymbol -> {
-                val fqName = symbol.callableIdIfNonLocal
-                    ?: error("fqName should not be null for non-local declaration")
-                fqName.classId
-            }
-            is KtConstructorSymbol -> {
-                symbol.containingClassIdIfNonLocal
-                    ?: error("fqName should not be null for non-local declaration")
-            }
-            else -> error("We should not have a ${symbol::class} from a library")
-        } ?: error("outerClassId should not be null for member declaration")
-        val containingClass = getClassOrObjectSymbolByClassId(containingClassId)
-        return containingClass ?: error("Class by class id should exists")
-    }
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KDocReferenceResolver.kt

@@ -35,6 +35,8 @@ internal object KDocReferenceResolver {
                     is KtNamedClassOrObjectSymbol -> {
                         collectPrimaryConstructorParameterSymbols(ownerSymbol, singleSegment)
                     }
+
+                    else -> {}
                 }
             }
         }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/ktSymbolUtils.kt

@@ -6,14 +6,14 @@
 package org.jetbrains.kotlin.analysis.api.fir.utils
 
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.llFirModuleData
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.fir.dispatchReceiverClassOrNull
 import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
 
 internal val KtSymbol.firSymbol: FirBasedSymbol<*>
     get() {
@@ -21,6 +21,17 @@ internal val KtSymbol.firSymbol: FirBasedSymbol<*>
         return this.firSymbol
     }
 
+internal val KtTypeParameterSymbol.firSymbol: FirTypeParameterSymbol get() = (this as KtFirSymbol<*>).firSymbol as FirTypeParameterSymbol
+internal val KtTypeAliasSymbol.firSymbol: FirTypeAliasSymbol get() = (this as KtFirSymbol<*>).firSymbol as FirTypeAliasSymbol
+
+internal val KtCallableSymbol.firSymbol: FirCallableSymbol<*> get() = (this as KtFirSymbol<*>).firSymbol as FirCallableSymbol<*>
+internal val KtValueParameterSymbol.firSymbol: FirValueParameterSymbol get() = (this as KtFirSymbol<*>).firSymbol as FirValueParameterSymbol
+internal val KtEnumEntrySymbol.firSymbol: FirEnumEntrySymbol get() = (this as KtFirSymbol<*>).firSymbol as FirEnumEntrySymbol
+internal val KtConstructorSymbol.firSymbol: FirConstructorSymbol get() = (this as KtFirSymbol<*>).firSymbol as FirConstructorSymbol
+internal val KtPropertyAccessorSymbol.firSymbol: FirPropertyAccessorSymbol get() = (this as KtFirSymbol<*>).firSymbol as FirPropertyAccessorSymbol
+internal val KtClassInitializerSymbol.firSymbol: FirAnonymousInitializerSymbol get() = (this as KtFirSymbol<*>).firSymbol as FirAnonymousInitializerSymbol
+
+
 fun FirBasedSymbol<*>.getContainingKtModule(firResolveSession: LLFirResolveSession): KtModule {
     val target = when (this) {
         is FirCallableSymbol -> {

analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.fir.test.cases.generated.cases.components.containingDeclarationProvider;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.analysis.api.fir.test.configurators.AnalysisApiFirTestConfiguratorFactory;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode;
+import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider.AbstractContainingDeclarationProviderByMemberScopeTest;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope")
+@TestDataPath("$PROJECT_ROOT")
+public class FirIdeDependentAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated extends AbstractContainingDeclarationProviderByMemberScopeTest {
+    @NotNull
+    @Override
+    public AnalysisApiTestConfigurator getConfigurator() {
+        return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator(
+            new AnalysisApiTestConfiguratorFactoryData(
+                FrontendKind.Fir,
+                TestModuleKind.Source,
+                AnalysisSessionMode.Dependent,
+                AnalysisApiMode.Ide
+            )
+        );
+    }
+
+    @Test
+    public void testAllFilesPresentInContainingDeclarationFromMemberScope() throws Exception {
+        KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope"), Pattern.compile("^(.+)\\.kt$"), null, true);
+    }
+
+    @Test
+    @TestMetadata("intersectionOverride.kt")
+    public void testIntersectionOverride() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.kt");
+    }
+
+    @Test
+    @TestMetadata("subsitutionOverride.kt")
+    public void testSubsitutionOverride() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.kt");
+    }
+}

analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.fir.test.cases.generated.cases.components.containingDeclarationProvider;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.analysis.api.fir.test.configurators.AnalysisApiFirTestConfiguratorFactory;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode;
+import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider.AbstractContainingDeclarationProviderByPsiTest;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi")
+@TestDataPath("$PROJECT_ROOT")
+public class FirIdeDependentAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated extends AbstractContainingDeclarationProviderByPsiTest {
+    @NotNull
+    @Override
+    public AnalysisApiTestConfigurator getConfigurator() {
+        return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator(
+            new AnalysisApiTestConfiguratorFactoryData(
+                FrontendKind.Fir,
+                TestModuleKind.Source,
+                AnalysisSessionMode.Dependent,
+                AnalysisApiMode.Ide
+            )
+        );
+    }
+
+    @Test
+    public void testAllFilesPresentInContainingDeclarationByPsi() throws Exception {
+        KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi"), Pattern.compile("^(.+)\\.kt$"), null, true);
+    }
+
+    @Test
+    @TestMetadata("classes.kt")
+    public void testClasses() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/classes.kt");
+    }
+
+    @Test
+    @TestMetadata("deeplyNestedCode.kt")
+    public void testDeeplyNestedCode() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/deeplyNestedCode.kt");
+    }
+
+    @Test
+    @TestMetadata("enums.kt")
+    public void testEnums() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/enums.kt");
+    }
+
+    @Test
+    @TestMetadata("functions.kt")
+    public void testFunctions() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/functions.kt");
+    }
+
+    @Test
+    @TestMetadata("localDeclarations.kt")
+    public void testLocalDeclarations() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/localDeclarations.kt");
+    }
+
+    @Test
+    @TestMetadata("typeAliases.kt")
+    public void testTypeAliases() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/typeAliases.kt");
+    }
+}

analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.fir.test.cases.generated.cases.components.containingDeclarationProvider;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.analysis.api.fir.test.configurators.AnalysisApiFirTestConfiguratorFactory;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode;
+import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider.AbstractContainingDeclarationProviderByMemberScopeTest;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope")
+@TestDataPath("$PROJECT_ROOT")
+public class FirIdeNormalAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated extends AbstractContainingDeclarationProviderByMemberScopeTest {
+    @NotNull
+    @Override
+    public AnalysisApiTestConfigurator getConfigurator() {
+        return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator(
+            new AnalysisApiTestConfiguratorFactoryData(
+                FrontendKind.Fir,
+                TestModuleKind.Source,
+                AnalysisSessionMode.Normal,
+                AnalysisApiMode.Ide
+            )
+        );
+    }
+
+    @Test
+    public void testAllFilesPresentInContainingDeclarationFromMemberScope() throws Exception {
+        KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope"), Pattern.compile("^(.+)\\.kt$"), null, true);
+    }
+
+    @Test
+    @TestMetadata("intersectionOverride.kt")
+    public void testIntersectionOverride() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.kt");
+    }
+
+    @Test
+    @TestMetadata("subsitutionOverride.kt")
+    public void testSubsitutionOverride() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.kt");
+    }
+}

analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.fir.test.cases.generated.cases.components.containingDeclarationProvider;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.analysis.api.fir.test.configurators.AnalysisApiFirTestConfiguratorFactory;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode;
+import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider.AbstractContainingDeclarationProviderByPsiTest;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi")
+@TestDataPath("$PROJECT_ROOT")
+public class FirIdeNormalAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated extends AbstractContainingDeclarationProviderByPsiTest {
+    @NotNull
+    @Override
+    public AnalysisApiTestConfigurator getConfigurator() {
+        return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator(
+            new AnalysisApiTestConfiguratorFactoryData(
+                FrontendKind.Fir,
+                TestModuleKind.Source,
+                AnalysisSessionMode.Normal,
+                AnalysisApiMode.Ide
+            )
+        );
+    }
+
+    @Test
+    public void testAllFilesPresentInContainingDeclarationByPsi() throws Exception {
+        KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi"), Pattern.compile("^(.+)\\.kt$"), null, true);
+    }
+
+    @Test
+    @TestMetadata("classes.kt")
+    public void testClasses() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/classes.kt");
+    }
+
+    @Test
+    @TestMetadata("deeplyNestedCode.kt")
+    public void testDeeplyNestedCode() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/deeplyNestedCode.kt");
+    }
+
+    @Test
+    @TestMetadata("enums.kt")
+    public void testEnums() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/enums.kt");
+    }
+
+    @Test
+    @TestMetadata("functions.kt")
+    public void testFunctions() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/functions.kt");
+    }
+
+    @Test
+    @TestMetadata("localDeclarations.kt")
+    public void testLocalDeclarations() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/localDeclarations.kt");
+    }
+
+    @Test
+    @TestMetadata("typeAliases.kt")
+    public void testTypeAliases() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/typeAliases.kt");
+    }
+}

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/containingDeclarationProvider/AbstractContainingDeclarationProviderByMemberScopeTest.kt

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider
+
+import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
+import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
+import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.assertions
+
+abstract class AbstractContainingDeclarationProviderByMemberScopeTest : AbstractAnalysisApiSingleFileTest() {
+    override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
+        val declaration = testServices.expressionMarkerProvider.getElementOfTypeAtCaret<KtClassOrObject>(ktFile)
+
+        val memberToContainingClass = analyseForTest(declaration) {
+            val symbol = declaration.getClassOrObjectSymbol()
+            prettyPrint {
+                printCollection(symbol.getMemberScope().getAllSymbols().toList(), separator = "\n\n") { symbol ->
+                    val containingDeclaration = symbol.getContainingSymbol() as KtClassLikeSymbol
+                    append(symbol.render(renderingOptions))
+                    append(" fromClass ")
+                    append(containingDeclaration.classIdIfNonLocal?.asString())
+                    if (symbol.typeParameters.isNotEmpty()) {
+                        appendLine()
+                        withIndent {
+                            printCollection(symbol.typeParameters, separator = "\n") { typeParameter ->
+                                val containingDeclarationForTypeParameter = typeParameter.getContainingSymbol()
+                                append(typeParameter.render(renderingOptions))
+                                append(" from ")
+                                append(containingDeclarationForTypeParameter?.qualifiedNameString())
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        testServices.assertions.assertEqualsToTestDataFileSibling(memberToContainingClass)
+    }
+
+    private fun KtSymbol.qualifiedNameString() = when (this) {
+        is KtClassLikeSymbol -> classIdIfNonLocal!!.asString()
+        is KtCallableSymbol -> callableIdIfNonLocal!!.toString()
+        else -> error("unknown symbol $this")
+    }
+
+    companion object {
+        val renderingOptions = KtDeclarationRendererOptions.DEFAULT.copy(
+            typeRendererOptions = KtTypeRendererOptions.SHORT_NAMES,
+            modifiers = emptySet()
+        )
+    }
+}

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/containingDeclarationProvider/AbstractContainingDeclarationProviderByPsiTest.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtVisitorVoid
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.assertions
+
+abstract class AbstractContainingDeclarationProviderByPsiTest : AbstractAnalysisApiSingleFileTest() {
+    override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
+        val currentPath = mutableListOf<KtDeclaration>()
+        analyseForTest(ktFile.declarations.first()) {
+            ktFile.accept(object : KtVisitorVoid() {
+                override fun visitElement(element: PsiElement) {
+                    element.acceptChildren(this)
+                }
+
+                override fun visitDeclaration(dcl: KtDeclaration) {
+                    val parentDeclaration = currentPath.lastOrNull()
+                    val currentDeclarationSymbol = dcl.getSymbol()
+                    val expectedParentDeclarationSymbol = parentDeclaration?.getSymbol()
+                    val actualParentDeclarationSymbol = currentDeclarationSymbol.getContainingSymbol()
+                    testServices.assertions.assertEquals(expectedParentDeclarationSymbol, actualParentDeclarationSymbol) {
+                        "Invalid parent declaration for $currentDeclarationSymbol, expected $expectedParentDeclarationSymbol but $actualParentDeclarationSymbol found"
+                    }
+
+                    currentPath.add(dcl)
+                    super.visitDeclaration(dcl)
+                    currentPath.removeLast()
+                }
+            })
+        }
+
+    }
+}

analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirStandaloneNormalAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.standalone.fir.test.cases.generated.cases.components.containingDeclarationProvider;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode;
+import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider.AbstractContainingDeclarationProviderByMemberScopeTest;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope")
+@TestDataPath("$PROJECT_ROOT")
+public class FirStandaloneNormalAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated extends AbstractContainingDeclarationProviderByMemberScopeTest {
+    @NotNull
+    @Override
+    public AnalysisApiTestConfigurator getConfigurator() {
+        return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator(
+            new AnalysisApiTestConfiguratorFactoryData(
+                FrontendKind.Fir,
+                TestModuleKind.Source,
+                AnalysisSessionMode.Normal,
+                AnalysisApiMode.Standalone
+            )
+        );
+    }
+
+    @Test
+    public void testAllFilesPresentInContainingDeclarationFromMemberScope() throws Exception {
+        KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope"), Pattern.compile("^(.+)\\.kt$"), null, true);
+    }
+
+    @Test
+    @TestMetadata("intersectionOverride.kt")
+    public void testIntersectionOverride() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.kt");
+    }
+
+    @Test
+    @TestMetadata("subsitutionOverride.kt")
+    public void testSubsitutionOverride() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.kt");
+    }
+}

analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirStandaloneNormalAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.standalone.fir.test.cases.generated.cases.components.containingDeclarationProvider;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.analysis.api.standalone.fir.test.AnalysisApiFirStandaloneModeTestConfiguratorFactory;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.FrontendKind;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisSessionMode;
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode;
+import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider.AbstractContainingDeclarationProviderByPsiTest;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi")
+@TestDataPath("$PROJECT_ROOT")
+public class FirStandaloneNormalAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated extends AbstractContainingDeclarationProviderByPsiTest {
+    @NotNull
+    @Override
+    public AnalysisApiTestConfigurator getConfigurator() {
+        return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator(
+            new AnalysisApiTestConfiguratorFactoryData(
+                FrontendKind.Fir,
+                TestModuleKind.Source,
+                AnalysisSessionMode.Normal,
+                AnalysisApiMode.Standalone
+            )
+        );
+    }
+
+    @Test
+    public void testAllFilesPresentInContainingDeclarationByPsi() throws Exception {
+        KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi"), Pattern.compile("^(.+)\\.kt$"), null, true);
+    }
+
+    @Test
+    @TestMetadata("classes.kt")
+    public void testClasses() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/classes.kt");
+    }
+
+    @Test
+    @TestMetadata("deeplyNestedCode.kt")
+    public void testDeeplyNestedCode() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/deeplyNestedCode.kt");
+    }
+
+    @Test
+    @TestMetadata("enums.kt")
+    public void testEnums() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/enums.kt");
+    }
+
+    @Test
+    @TestMetadata("functions.kt")
+    public void testFunctions() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/functions.kt");
+    }
+
+    @Test
+    @TestMetadata("localDeclarations.kt")
+    public void testLocalDeclarations() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/localDeclarations.kt");
+    }
+
+    @Test
+    @TestMetadata("typeAliases.kt")
+    public void testTypeAliases() throws Exception {
+        runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/typeAliases.kt");
+    }
+}

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtSymbolContainingDeclarationProvider.kt

@@ -6,12 +6,13 @@
 package org.jetbrains.kotlin.analysis.api.components
 
 import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
+import org.jetbrains.kotlin.analysis.api.symbols.KtDeclarationSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 
 public abstract class KtSymbolContainingDeclarationProvider : KtAnalysisSessionComponent() {
-    public abstract fun getContainingDeclaration(symbol: KtSymbol): KtSymbolWithKind?
+    public abstract fun getContainingDeclaration(symbol: KtSymbol): KtDeclarationSymbol?
 
     public abstract fun getContainingModule(symbol: KtSymbol): KtModule
 }
@@ -23,7 +24,7 @@ public interface KtSymbolContainingDeclarationProviderMixIn : KtAnalysisSessionM
      *   for class members returns containing class
      *   for local declaration returns declaration it was declared it
      */
-    public fun KtSymbol.getContainingSymbol(): KtSymbolWithKind? =
+    public fun KtSymbol.getContainingSymbol(): KtDeclarationSymbol? =
         withValidityAssertion { analysisSession.containingDeclarationProvider.getContainingDeclaration(this) }
 
     public fun KtSymbol.getContainingModule(): KtModule =

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/KtSymbolProvider.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 
 public abstract class KtSymbolProvider : KtAnalysisSessionComponent() {
-    public open fun getSymbol(psi: KtDeclaration): KtSymbol = when (psi) {
+    public open fun getSymbol(psi: KtDeclaration): KtDeclarationSymbol = when (psi) {
         is KtParameter -> getParameterSymbol(psi)
         is KtNamedFunction -> getFunctionLikeSymbol(psi)
         is KtConstructor<*> -> getConstructorSymbol(psi)
@@ -62,7 +62,7 @@ public abstract class KtSymbolProvider : KtAnalysisSessionComponent() {
 }
 
 public interface KtSymbolProviderMixIn : KtAnalysisSessionMixIn {
-    public fun KtDeclaration.getSymbol(): KtSymbol =
+    public fun KtDeclaration.getSymbol(): KtDeclarationSymbol =
         withValidityAssertion { analysisSession.symbolProvider.getSymbol(this) }
 
     /**

analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/classes.kt

@@ -0,0 +1,26 @@
+class A {
+    class B {
+        class C {
+
+        }
+    }
+}
+
+interface D {
+    inner class E {
+        enum class F {
+
+        }
+    }
+}
+
+enum class G {
+    H, I
+}
+
+
+fun foo() {
+    class D {
+
+    }
+}

analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/deeplyNestedCode.kt

@@ -0,0 +1,17 @@
+class X {
+    fun foo() {
+        class U {
+            inner class K {
+                inner class D {
+                    fun check() {
+                        class F {
+                            inner class L
+                        }
+                    }
+                }
+            }
+
+            class T
+        }
+    }
+}

analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/enums.kt

@@ -0,0 +1,23 @@
+enum class A {
+    B, C;
+    fun d(){}
+    val e: Int = 10
+}
+
+class X {
+    private Y {
+        enum class U {
+            UB, UC;
+            fun ud(){}
+            val ue: Int = 10
+        }
+    }
+
+     class P {
+        enum class W {
+            WB, WC;
+            fun wd(){}
+            val we: Int = 10
+        }
+    }
+}

analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/functions.kt

@@ -0,0 +1,40 @@
+fun a(){}
+private fun b() {}
+
+class A {
+    private fun a() {}
+
+    class B {
+        private fun b() {}
+
+        class C {
+            private fun c() {}
+
+        }
+    }
+}
+
+interface D {
+    private fun d() {}
+    inner class E {
+        private fun e() {}
+        enum class F {
+            private fun f() {}
+        }
+    }
+}
+
+enum class G {
+    H, I;
+
+    private fun g() {}
+}
+
+
+fun foo() {
+    private fun fooA() {}
+
+    class FooI {
+        private fun m() {}
+    }
+}

analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/localDeclarations.kt

@@ -0,0 +1,27 @@
+fun x() {
+    val xProperty = 10
+    fun xFunction() = 11
+    typealias xTypealias = 10
+    class XClass<XT> {}
+    enum class XEnum {
+        X_ENUM_ENTRY;
+
+        fun xEnumMember(){}
+    }
+
+    class Y <YT> {
+        val yProperty = 10
+        fun yFunction() = 11
+        typealias yTypealias = 10
+        class YClass<YTT> {}
+        enum class YEnum {
+            Y_ENUM_ENTRY;
+
+            fun yEnumMember(){}
+
+        }
+        init {
+            println("init block in local class")
+        }
+    }
+}

analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/typeAliases.kt

@@ -0,0 +1,12 @@
+typealias X<XT> = List<X>
+class A {
+    typealias Y<YS, YV> = Map<YS, YV>
+
+    class B {
+        typealias Q<QS, QV> = MutableMap<QS, QV>
+    }
+}
+
+fun foo() {
+    typealias L<LS, LV> = Map<LS, LV>
+}

analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.kt

@@ -0,0 +1,9 @@
+interface A {
+    fun <T>foo()
+}
+
+interface B {
+    fun <T>foo() {}
+}
+
+>class Y<caret> : A, B

analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.txt

@@ -0,0 +1,10 @@
+fun <T> foo() fromClass Y
+  T from /Y.foo
+
+fun equals(other: Any?): Boolean fromClass kotlin/Any
+
+fun hashCode(): Int fromClass kotlin/Any
+
+fun toString(): String fromClass kotlin/Any
+
+constructor() fromClass Y

analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.kt

@@ -0,0 +1,7 @@
+abstract class X<T> {
+    fun <S> foo1(t: T): T = t
+    fun <Q> foo2(t: T) {}
+    fun <U> foo3() {}
+}
+
+class Y<caret> : X<Int> {}

analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.txt

@@ -0,0 +1,16 @@
+fun <S> foo1(t: Int): Int fromClass Y
+  S from /Y.foo1
+
+fun <Q> foo2(t: Int) fromClass Y
+  Q from /Y.foo2
+
+fun <U> foo3() fromClass X
+  U from /X.foo3
+
+fun equals(other: Any?): Boolean fromClass kotlin/Any
+
+fun hashCode(): Int fromClass kotlin/Any
+
+fun toString(): String fromClass kotlin/Any
+
+constructor() fromClass Y

generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt

@@ -11,6 +11,8 @@ import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.annotations.Abstra
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.callResolver.AbstractResolveCallTest
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.callResolver.AbstractResolveCandidatesTest
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.compileTimeConstantProvider.AbstractCompileTimeConstantEvaluatorTest
+import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider.AbstractContainingDeclarationProviderByMemberScopeTest
+import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider.AbstractContainingDeclarationProviderByPsiTest
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.diagnosticProvider.AbstractCollectDiagnosticsTest
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.expressionInfoProvider.AbstractReturnTargetSymbolTest
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.expressionInfoProvider.AbstractWhenMissingCasesTest
@@ -230,6 +232,17 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() {
         }
     }
 
+    // for K1, symbols do not have a proper equality implementation, so the tests are failing
+    component("containingDeclarationProvider", filter = frontendIs(FrontendKind.Fir)) {
+        test(AbstractContainingDeclarationProviderByPsiTest::class) {
+            model("containingDeclarationByPsi")
+        }
+
+        test(AbstractContainingDeclarationProviderByMemberScopeTest::class) {
+            model("containingDeclarationFromMemberScope")
+        }
+    }
+
     component("importOptimizer") {
         test(
             AbstractAnalysisApiImportOptimizerTest::class,