From 97df0a0902b10d67f6760fef267a908889240593 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Fri, 14 Oct 2022 15:31:01 +0200 Subject: [PATCH] [Analysis API] rework containing declaration provider now it should work for non-source declarations --- ...Fe10SymbolContainingDeclarationProvider.kt | 24 +--- ...tFirSymbolContainingDeclarationProvider.kt | 135 ++++++------------ .../fir/references/KDocReferenceResolver.kt | 2 + .../analysis/api/fir/utils/ktSymbolUtils.kt | 15 +- ...ionProviderByMemberScopeTestGenerated.java | 60 ++++++++ ...DeclarationProviderByPsiTestGenerated.java | 84 +++++++++++ ...ionProviderByMemberScopeTestGenerated.java | 60 ++++++++ ...DeclarationProviderByPsiTestGenerated.java | 84 +++++++++++ ...ingDeclarationProviderByMemberScopeTest.kt | 65 +++++++++ ...tContainingDeclarationProviderByPsiTest.kt | 43 ++++++ ...ionProviderByMemberScopeTestGenerated.java | 60 ++++++++ ...DeclarationProviderByPsiTestGenerated.java | 84 +++++++++++ .../KtSymbolContainingDeclarationProvider.kt | 5 +- .../analysis/api/symbols/KtSymbolProvider.kt | 4 +- .../containingDeclarationByPsi/classes.kt | 26 ++++ .../deeplyNestedCode.kt | 17 +++ .../containingDeclarationByPsi/enums.kt | 23 +++ .../containingDeclarationByPsi/functions.kt | 40 ++++++ .../localDeclarations.kt | 27 ++++ .../containingDeclarationByPsi/typeAliases.kt | 12 ++ .../intersectionOverride.kt | 9 ++ .../intersectionOverride.txt | 10 ++ .../subsitutionOverride.kt | 7 + .../subsitutionOverride.txt | 16 +++ .../tests/analysis/api/analysisApi.kt | 13 ++ 25 files changed, 807 insertions(+), 118 deletions(-) create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java create mode 100644 analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/containingDeclarationProvider/AbstractContainingDeclarationProviderByMemberScopeTest.kt create mode 100644 analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/containingDeclarationProvider/AbstractContainingDeclarationProviderByPsiTest.kt create mode 100644 analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirStandaloneNormalAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java create mode 100644 analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirStandaloneNormalAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java create mode 100644 analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/classes.kt create mode 100644 analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/deeplyNestedCode.kt create mode 100644 analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/enums.kt create mode 100644 analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/functions.kt create mode 100644 analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/localDeclarations.kt create mode 100644 analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/typeAliases.kt create mode 100644 analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.kt create mode 100644 analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.txt create mode 100644 analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.kt create mode 100644 analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.txt diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolContainingDeclarationProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolContainingDeclarationProvider.kt index fd7c7143105..fbac54a8cb0 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolContainingDeclarationProvider.kt +++ b/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 } } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolContainingDeclarationProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolContainingDeclarationProvider.kt index 7043321a6af..b93e5b6b31e 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolContainingDeclarationProvider.kt +++ b/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") - } } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KDocReferenceResolver.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KDocReferenceResolver.kt index c497d5758b3..022cdb4eb19 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KDocReferenceResolver.kt +++ b/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 -> {} } } } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/ktSymbolUtils.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/ktSymbolUtils.kt index 2f6ac44e429..09e7c4b486f 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/ktSymbolUtils.kt +++ b/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 -> { diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java new file mode 100644 index 00000000000..ccfb5b6433c --- /dev/null +++ b/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"); + } +} diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java new file mode 100644 index 00000000000..d722eee7af5 --- /dev/null +++ b/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"); + } +} diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java new file mode 100644 index 00000000000..306e2a85d88 --- /dev/null +++ b/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"); + } +} diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java new file mode 100644 index 00000000000..b198a2c36b5 --- /dev/null +++ b/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"); + } +} diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/containingDeclarationProvider/AbstractContainingDeclarationProviderByMemberScopeTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/containingDeclarationProvider/AbstractContainingDeclarationProviderByMemberScopeTest.kt new file mode 100644 index 00000000000..b5d60aee530 --- /dev/null +++ b/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(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() + ) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/containingDeclarationProvider/AbstractContainingDeclarationProviderByPsiTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/containingDeclarationProvider/AbstractContainingDeclarationProviderByPsiTest.kt new file mode 100644 index 00000000000..69e6ee69fef --- /dev/null +++ b/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() + 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() + } + }) + } + + } +} \ No newline at end of file diff --git a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirStandaloneNormalAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirStandaloneNormalAnalysisSourceModuleContainingDeclarationProviderByMemberScopeTestGenerated.java new file mode 100644 index 00000000000..942d102e03c --- /dev/null +++ b/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"); + } +} diff --git a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirStandaloneNormalAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirStandaloneNormalAnalysisSourceModuleContainingDeclarationProviderByPsiTestGenerated.java new file mode 100644 index 00000000000..b881290961f --- /dev/null +++ b/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"); + } +} diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtSymbolContainingDeclarationProvider.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtSymbolContainingDeclarationProvider.kt index 8327f3b9fc5..3ef239e060f 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtSymbolContainingDeclarationProvider.kt +++ b/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 = diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/KtSymbolProvider.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/KtSymbolProvider.kt index 3ab06562acc..47715aaba37 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/KtSymbolProvider.kt +++ b/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) } /** diff --git a/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/classes.kt b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/classes.kt new file mode 100644 index 00000000000..3e9f7f6f424 --- /dev/null +++ b/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 { + + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/deeplyNestedCode.kt b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/deeplyNestedCode.kt new file mode 100644 index 00000000000..031d0887326 --- /dev/null +++ b/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 + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/enums.kt b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/enums.kt new file mode 100644 index 00000000000..ab4399f3f3b --- /dev/null +++ b/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 + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/functions.kt b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/functions.kt new file mode 100644 index 00000000000..1c492590185 --- /dev/null +++ b/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() {} + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/localDeclarations.kt b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/localDeclarations.kt new file mode 100644 index 00000000000..b30c9682fdb --- /dev/null +++ b/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 {} + enum class XEnum { + X_ENUM_ENTRY; + + fun xEnumMember(){} + } + + class Y { + val yProperty = 10 + fun yFunction() = 11 + typealias yTypealias = 10 + class YClass {} + enum class YEnum { + Y_ENUM_ENTRY; + + fun yEnumMember(){} + + } + init { + println("init block in local class") + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/typeAliases.kt b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/typeAliases.kt new file mode 100644 index 00000000000..14058db7b49 --- /dev/null +++ b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/typeAliases.kt @@ -0,0 +1,12 @@ +typealias X = List +class A { + typealias Y = Map + + class B { + typealias Q = MutableMap + } +} + +fun foo() { + typealias L = Map +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.kt b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.kt new file mode 100644 index 00000000000..1c0c11b4999 --- /dev/null +++ b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.kt @@ -0,0 +1,9 @@ +interface A { + fun foo() +} + +interface B { + fun foo() {} +} + +>class Y : A, B \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.txt b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.txt new file mode 100644 index 00000000000..758afcff8d8 --- /dev/null +++ b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/intersectionOverride.txt @@ -0,0 +1,10 @@ +fun 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 \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.kt b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.kt new file mode 100644 index 00000000000..070a8eb8f1e --- /dev/null +++ b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.kt @@ -0,0 +1,7 @@ +abstract class X { + fun foo1(t: T): T = t + fun foo2(t: T) {} + fun foo3() {} +} + +class Y : X {} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.txt b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.txt new file mode 100644 index 00000000000..74c321dd46f --- /dev/null +++ b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationFromMemberScope/subsitutionOverride.txt @@ -0,0 +1,16 @@ +fun foo1(t: Int): Int fromClass Y + S from /Y.foo1 + +fun foo2(t: Int) fromClass Y + Q from /Y.foo2 + +fun 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 \ No newline at end of file diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt index 74d18d385c2..3a26a3f525a 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt +++ b/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,