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 2b3898fa597..e0f3b3bf45b 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 @@ -18,11 +18,15 @@ 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.low.level.api.fir.sessions.llFirSession +import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration import org.jetbrains.kotlin.analysis.project.structure.KtModule import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment import org.jetbrains.kotlin.analysis.utils.printer.parentOfType +import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol +import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin +import org.jetbrains.kotlin.fir.declarations.FirScript import org.jetbrains.kotlin.fir.diagnostics.ConeDestructuringDeclarationsOnTopLevel import org.jetbrains.kotlin.fir.resolve.providers.firProvider import org.jetbrains.kotlin.fir.symbols.impl.FirErrorPropertySymbol @@ -31,7 +35,7 @@ import org.jetbrains.kotlin.psi.* internal class KtFirSymbolContainingDeclarationProvider( override val analysisSession: KtFirAnalysisSession, - override val token: KtLifetimeToken + override val token: KtLifetimeToken, ) : KtSymbolContainingDeclarationProvider(), KtFirAnalysisSessionComponent { override fun getContainingDeclaration(symbol: KtSymbol): KtDeclarationSymbol? { if (symbol is KtReceiverParameterSymbol) { @@ -39,7 +43,12 @@ internal class KtFirSymbolContainingDeclarationProvider( } if (symbol !is KtDeclarationSymbol) return null - if (symbol is KtSymbolWithKind && symbol.symbolKind == KtSymbolKind.TOP_LEVEL) return null + if (symbol is KtSymbolWithKind && + symbol.symbolKind == KtSymbolKind.TOP_LEVEL && + // Should be replaced with proper check after KT-61451 and KT-61887 + (symbol.firSymbol.fir as? FirElementWithResolveState)?.getContainingFile()?.declarations?.firstOrNull() !is FirScript + ) return null + val firSymbol = symbol.firSymbol if (firSymbol is FirErrorPropertySymbol && firSymbol.diagnostic is ConeDestructuringDeclarationsOnTopLevel) return null fun getParentSymbolByPsi() = getContainingPsi(symbol).let { with(analysisSession) { it.getSymbol() } } @@ -73,7 +82,7 @@ internal class KtFirSymbolContainingDeclarationProvider( is KtClassLikeSymbol -> { val classId = symbol.classIdIfNonLocal ?: return getParentSymbolByPsi() // local - val outerClassId = classId.outerClassId ?: return null // toplevel + val outerClassId = classId.outerClassId ?: return getParentSymbolByPsi() // top-level or inside script val outerFirClassifier = symbol.firSymbol.llFirSession.firProvider.getFirClassifierByFqName(outerClassId) ?: return null firSymbolBuilder.buildSymbol(outerFirClassifier) as? KtDeclarationSymbol } @@ -102,13 +111,14 @@ internal class KtFirSymbolContainingDeclarationProvider( } } - return when (symbol.origin) { - KtSymbolOrigin.SOURCE -> thisSource.getContainingKtDeclaration() + val origin = symbol.origin + return when { + origin == KtSymbolOrigin.SOURCE || symbol.firSymbol.fir.origin == FirDeclarationOrigin.ScriptCustomization.ResultProperty -> thisSource.getContainingKtDeclaration() ?: errorWithAttachment("Containing declaration should present for non-toplevel declaration ${thisSource::class}") { withSymbolAttachment("symbolForContainingPsi", symbol, analysisSession) } - KtSymbolOrigin.SOURCE_MEMBER_GENERATED -> thisSource as KtDeclaration + origin == KtSymbolOrigin.SOURCE_MEMBER_GENERATED -> thisSource as KtDeclaration else -> errorWithAttachment("Unsupported declaration origin ${symbol.origin} ${thisSource::class}") { withSymbolAttachment("symbolForContainingPsi", symbol, analysisSession) } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt index 438a8909c7d..8bd255ab50c 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.UnsupportedSymbolKind import org.jetbrains.kotlin.analysis.api.symbols.pointers.symbolPointerOfType import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries +import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.containingClassLookupTag @@ -136,16 +137,7 @@ internal class KtFirKotlinPropertySymbol( return when (val kind = symbolKind) { KtSymbolKind.TOP_LEVEL -> { if (firSymbol.fir.origin is FirDeclarationOrigin.ScriptCustomization.ResultProperty) { - val file = psi?.containingFile as? KtFile - if (file == null) { - errorWithFirSpecificEntries( - "ResultProperty restoring supported only for psi-based symbols yet", - fir = firSymbol.fir, - psi = psi, - ) - } - - KtFirResultPropertySymbolPointer(file.symbolPointerOfType()) + KtFirResultPropertySymbolPointer(requireOwnerPointer()) } else { KtFirTopLevelPropertySymbolPointer( firSymbol.callableId, diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirScriptSymbol.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirScriptSymbol.kt index 70c106da3e6..215029405a6 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirScriptSymbol.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirScriptSymbol.kt @@ -9,15 +9,20 @@ import com.intellij.psi.PsiElement import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration +import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirScriptSymbolPointer import org.jetbrains.kotlin.analysis.api.fir.utils.cached import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion import org.jetbrains.kotlin.analysis.api.symbols.KtScriptSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.fir.symbols.impl.FirScriptSymbol +import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile +import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.psi +import org.jetbrains.kotlin.fir.symbols.impl.FirScriptSymbol +import org.jetbrains.kotlin.fir.utils.exceptions.withFirSymbolEntry import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment internal class KtFirScriptSymbol( override val firSymbol: FirScriptSymbol, @@ -43,7 +48,12 @@ internal class KtFirScriptSymbol( context(KtAnalysisSession) override fun createPointer(): KtSymbolPointer = withValidityAssertion { KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it } - TODO("Creating pointers for files from library is not supported yet") + + val firFile = firSymbol.fir.getContainingFile() ?: errorWithAttachment("${FirFile::class.simpleName} is not found") { + withFirSymbolEntry("script", firSymbol) + } + + firFile.symbol.let(builder::buildFileSymbol).createPointer().let(::KtFirScriptSymbolPointer) } override fun equals(other: Any?): Boolean = symbolEquals(other) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirResultPropertySymbolPointer.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirResultPropertySymbolPointer.kt index 33a05fbd9d4..c96086c86ef 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirResultPropertySymbolPointer.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirResultPropertySymbolPointer.kt @@ -7,24 +7,24 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols.pointers import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession -import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirFileSymbol +import org.jetbrains.kotlin.analysis.api.fir.utils.firSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol +import org.jetbrains.kotlin.analysis.api.symbols.KtScriptSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.declarations.FirScript -internal class KtFirResultPropertySymbolPointer(private val filePointer: KtSymbolPointer) : +internal class KtFirResultPropertySymbolPointer(private val scriptPointer: KtSymbolPointer) : KtSymbolPointer() { @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol") override fun restoreSymbol(analysisSession: KtAnalysisSession): KtKotlinPropertySymbol? { require(analysisSession is KtFirAnalysisSession) - val file = with(analysisSession) { - filePointer.restoreSymbol()?.firSymbol + val script = with(analysisSession) { + scriptPointer.restoreSymbol()?.firSymbol?.fir as? FirScript } ?: return null - val script = file.fir.declarations.singleOrNull() as? FirScript ?: return null val lastProperty = script.statements.lastOrNull() as? FirProperty ?: return null if (lastProperty.origin !is FirDeclarationOrigin.ScriptCustomization.ResultProperty) return null return analysisSession.firSymbolBuilder.variableLikeBuilder.buildPropertySymbol(lastProperty.symbol) as? KtKotlinPropertySymbol @@ -32,5 +32,5 @@ internal class KtFirResultPropertySymbolPointer(private val filePointer: KtSymbo override fun pointsToTheSameSymbolAs(other: KtSymbolPointer): Boolean = this === other || other is KtFirResultPropertySymbolPointer && - other.filePointer.pointsToTheSameSymbolAs(filePointer) + other.scriptPointer.pointsToTheSameSymbolAs(scriptPointer) } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirScriptSymbolPointer.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirScriptSymbolPointer.kt new file mode 100644 index 00000000000..06aea662ed0 --- /dev/null +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirScriptSymbolPointer.kt @@ -0,0 +1,33 @@ +/* + * Copyright 2010-2023 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.symbols.pointers + +import org.jetbrains.kotlin.analysis.api.KtAnalysisSession +import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession +import org.jetbrains.kotlin.analysis.api.fir.utils.firSymbol +import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol +import org.jetbrains.kotlin.analysis.api.symbols.KtScriptSymbol +import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol +import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirScript + +internal class KtFirScriptSymbolPointer(private val filePointer: KtSymbolPointer) : KtSymbolPointer() { + @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol") + override fun restoreSymbol(analysisSession: KtAnalysisSession): KtScriptSymbol? { + require(analysisSession is KtFirAnalysisSession) + val file = with(analysisSession) { + filePointer.restoreSymbol()?.firSymbol?.fir as? FirFile + } ?: return null + + val script = file.declarations.singleOrNull() as? FirScript ?: return null + return analysisSession.firSymbolBuilder.buildScriptSymbol(script.symbol) + } + + override fun pointsToTheSameSymbolAs(other: KtSymbolPointer): Boolean = this === other || + other is KtFirScriptSymbolPointer && + other.filePointer.pointsToTheSameSymbolAs(filePointer) +} diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisScriptSourceModuleContainingDeclarationProviderByPsiTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisScriptSourceModuleContainingDeclarationProviderByPsiTestGenerated.java index 131a2734dea..593bffd0b75 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisScriptSourceModuleContainingDeclarationProviderByPsiTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeDependentAnalysisScriptSourceModuleContainingDeclarationProviderByPsiTestGenerated.java @@ -45,4 +45,10 @@ public class FirIdeDependentAnalysisScriptSourceModuleContainingDeclarationProvi public void testAllFilesPresentInContainingDeclarationByPsi() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi"), Pattern.compile("^(.+)\\.kts$"), null, true); } + + @Test + @TestMetadata("scriptWithResultProperty.kts") + public void testScriptWithResultProperty() throws Exception { + runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/scriptWithResultProperty.kts"); + } } diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisScriptSourceModuleContainingDeclarationProviderByPsiTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisScriptSourceModuleContainingDeclarationProviderByPsiTestGenerated.java index 3eb6201cbae..fb34802b627 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisScriptSourceModuleContainingDeclarationProviderByPsiTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/containingDeclarationProvider/FirIdeNormalAnalysisScriptSourceModuleContainingDeclarationProviderByPsiTestGenerated.java @@ -45,4 +45,10 @@ public class FirIdeNormalAnalysisScriptSourceModuleContainingDeclarationProvider public void testAllFilesPresentInContainingDeclarationByPsi() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi"), Pattern.compile("^(.+)\\.kts$"), null, true); } + + @Test + @TestMetadata("scriptWithResultProperty.kts") + public void testScriptWithResultProperty() throws Exception { + runTest("analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/scriptWithResultProperty.kts"); + } } diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeDependentAnalysisScriptSourceModuleReferenceResolveTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeDependentAnalysisScriptSourceModuleReferenceResolveTestGenerated.java new file mode 100644 index 00000000000..47f81624afa --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeDependentAnalysisScriptSourceModuleReferenceResolveTestGenerated.java @@ -0,0 +1,454 @@ +/* + * Copyright 2010-2023 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.references; + +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.references.AbstractReferenceResolveTest; +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/referenceResolve") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeDependentAnalysisScriptSourceModuleReferenceResolveTestGenerated extends AbstractReferenceResolveTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.ScriptSource, + AnalysisSessionMode.Dependent, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInReferenceResolve() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Test + @TestMetadata("ScriptResult.kts") + public void testScriptResult() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ScriptResult.kts"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/arrayAccess") + @TestDataPath("$PROJECT_ROOT") + public class ArrayAccess { + @Test + public void testAllFilesPresentInArrayAccess() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/arrayAccess"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/arrayAccess/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/arrayAccess/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference") + @TestDataPath("$PROJECT_ROOT") + public class ConstructorDelegatingReference { + @Test + public void testAllFilesPresentInConstructorDelegatingReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/danglingAnnotations") + @TestDataPath("$PROJECT_ROOT") + public class DanglingAnnotations { + @Test + public void testAllFilesPresentInDanglingAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/danglingAnnotations"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors") + @TestDataPath("$PROJECT_ROOT") + public class DelegatedPropertyAccessors { + @Test + public void testAllFilesPresentInDelegatedPropertyAccessors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource") + @TestDataPath("$PROJECT_ROOT") + public class InSource { + @Test + public void testAllFilesPresentInInSource() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary") + @TestDataPath("$PROJECT_ROOT") + public class InStandardLibrary { + @Test + public void testAllFilesPresentInInStandardLibrary() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn") + @TestDataPath("$PROJECT_ROOT") + public class ForLoopIn { + @Test + public void testAllFilesPresentInForLoopIn() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns") + @TestDataPath("$PROJECT_ROOT") + public class InBuiltIns { + @Test + public void testAllFilesPresentInInBuiltIns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inLibrary") + @TestDataPath("$PROJECT_ROOT") + public class InLibrary { + @Test + public void testAllFilesPresentInInLibrary() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inLibrary"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource") + @TestDataPath("$PROJECT_ROOT") + public class InSource { + @Test + public void testAllFilesPresentInInSource() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/inImport") + @TestDataPath("$PROJECT_ROOT") + public class InImport { + @Test + public void testAllFilesPresentInInImport() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/inImport"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/invoke") + @TestDataPath("$PROJECT_ROOT") + public class Invoke { + @Test + public void testAllFilesPresentInInvoke() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/invoke"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/invoke/onObjects") + @TestDataPath("$PROJECT_ROOT") + public class OnObjects { + @Test + public void testAllFilesPresentInOnObjects() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/invoke/onObjects"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/invoke/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/invoke/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc") + @TestDataPath("$PROJECT_ROOT") + public class KDoc { + @Test + public void testAllFilesPresentInKDoc() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/imports") + @TestDataPath("$PROJECT_ROOT") + public class Imports { + @Test + public void testAllFilesPresentInImports() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/imports"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/javaDeclarations") + @TestDataPath("$PROJECT_ROOT") + public class JavaDeclarations { + @Test + public void testAllFilesPresentInJavaDeclarations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/javaDeclarations"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/localContext") + @TestDataPath("$PROJECT_ROOT") + public class LocalContext { + @Test + public void testAllFilesPresentInLocalContext() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/localContext"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/parameters") + @TestDataPath("$PROJECT_ROOT") + public class Parameters { + @Test + public void testAllFilesPresentInParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/parameters"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/qualified") + @TestDataPath("$PROJECT_ROOT") + public class Qualified { + @Test + public void testAllFilesPresentInQualified() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/qualified"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/conflictResolution") + @TestDataPath("$PROJECT_ROOT") + public class ConflictResolution { + @Test + public void testAllFilesPresentInConflictResolution() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/conflictResolution"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/fromOtherFile") + @TestDataPath("$PROJECT_ROOT") + public class FromOtherFile { + @Test + public void testAllFilesPresentInFromOtherFile() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/fromOtherFile"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/stdlib") + @TestDataPath("$PROJECT_ROOT") + public class Stdlib { + @Test + public void testAllFilesPresentInStdlib() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/stdlib"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/thisQualifier") + @TestDataPath("$PROJECT_ROOT") + public class ThisQualifier { + @Test + public void testAllFilesPresentInThisQualifier() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/thisQualifier"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/nestedTypes") + @TestDataPath("$PROJECT_ROOT") + public class NestedTypes { + @Test + public void testAllFilesPresentInNestedTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/nestedTypes"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/packageReference") + @TestDataPath("$PROJECT_ROOT") + public class PackageReference { + @Test + public void testAllFilesPresentInPackageReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/packageReference"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/qualifiedAccess") + @TestDataPath("$PROJECT_ROOT") + public class QualifiedAccess { + @Test + public void testAllFilesPresentInQualifiedAccess() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/qualifiedAccess"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeArgument") + @TestDataPath("$PROJECT_ROOT") + public class TypeArgument { + @Test + public void testAllFilesPresentInTypeArgument() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeArgument"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeArgument/constant") + @TestDataPath("$PROJECT_ROOT") + public class Constant { + @Test + public void testAllFilesPresentInConstant() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeArgument/constant"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeArgument/functionCall") + @TestDataPath("$PROJECT_ROOT") + public class FunctionCall { + @Test + public void testAllFilesPresentInFunctionCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeArgument/functionCall"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeArgument/propertyAccess") + @TestDataPath("$PROJECT_ROOT") + public class PropertyAccess { + @Test + public void testAllFilesPresentInPropertyAccess() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeArgument/propertyAccess"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeArgument/type") + @TestDataPath("$PROJECT_ROOT") + public class Type { + @Test + public void testAllFilesPresentInType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeArgument/type"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeParameter") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameter { + @Test + public void testAllFilesPresentInTypeParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeParameter"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/withErrors/partiallyUnresolvedTypeQualifier") + @TestDataPath("$PROJECT_ROOT") + public class PartiallyUnresolvedTypeQualifier { + @Test + public void testAllFilesPresentInPartiallyUnresolvedTypeQualifier() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/withErrors/partiallyUnresolvedTypeQualifier"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } +} diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisScriptSourceModuleReferenceResolveTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisScriptSourceModuleReferenceResolveTestGenerated.java new file mode 100644 index 00000000000..8c2ccbea63b --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisScriptSourceModuleReferenceResolveTestGenerated.java @@ -0,0 +1,454 @@ +/* + * Copyright 2010-2023 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.references; + +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.references.AbstractReferenceResolveTest; +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/referenceResolve") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeNormalAnalysisScriptSourceModuleReferenceResolveTestGenerated extends AbstractReferenceResolveTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.ScriptSource, + AnalysisSessionMode.Normal, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInReferenceResolve() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Test + @TestMetadata("ScriptResult.kts") + public void testScriptResult() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ScriptResult.kts"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/arrayAccess") + @TestDataPath("$PROJECT_ROOT") + public class ArrayAccess { + @Test + public void testAllFilesPresentInArrayAccess() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/arrayAccess"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/arrayAccess/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/arrayAccess/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference") + @TestDataPath("$PROJECT_ROOT") + public class ConstructorDelegatingReference { + @Test + public void testAllFilesPresentInConstructorDelegatingReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/danglingAnnotations") + @TestDataPath("$PROJECT_ROOT") + public class DanglingAnnotations { + @Test + public void testAllFilesPresentInDanglingAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/danglingAnnotations"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors") + @TestDataPath("$PROJECT_ROOT") + public class DelegatedPropertyAccessors { + @Test + public void testAllFilesPresentInDelegatedPropertyAccessors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource") + @TestDataPath("$PROJECT_ROOT") + public class InSource { + @Test + public void testAllFilesPresentInInSource() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary") + @TestDataPath("$PROJECT_ROOT") + public class InStandardLibrary { + @Test + public void testAllFilesPresentInInStandardLibrary() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn") + @TestDataPath("$PROJECT_ROOT") + public class ForLoopIn { + @Test + public void testAllFilesPresentInForLoopIn() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns") + @TestDataPath("$PROJECT_ROOT") + public class InBuiltIns { + @Test + public void testAllFilesPresentInInBuiltIns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inLibrary") + @TestDataPath("$PROJECT_ROOT") + public class InLibrary { + @Test + public void testAllFilesPresentInInLibrary() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inLibrary"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource") + @TestDataPath("$PROJECT_ROOT") + public class InSource { + @Test + public void testAllFilesPresentInInSource() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/inImport") + @TestDataPath("$PROJECT_ROOT") + public class InImport { + @Test + public void testAllFilesPresentInInImport() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/inImport"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/invoke") + @TestDataPath("$PROJECT_ROOT") + public class Invoke { + @Test + public void testAllFilesPresentInInvoke() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/invoke"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/invoke/onObjects") + @TestDataPath("$PROJECT_ROOT") + public class OnObjects { + @Test + public void testAllFilesPresentInOnObjects() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/invoke/onObjects"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/invoke/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/invoke/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc") + @TestDataPath("$PROJECT_ROOT") + public class KDoc { + @Test + public void testAllFilesPresentInKDoc() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/imports") + @TestDataPath("$PROJECT_ROOT") + public class Imports { + @Test + public void testAllFilesPresentInImports() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/imports"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/javaDeclarations") + @TestDataPath("$PROJECT_ROOT") + public class JavaDeclarations { + @Test + public void testAllFilesPresentInJavaDeclarations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/javaDeclarations"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/localContext") + @TestDataPath("$PROJECT_ROOT") + public class LocalContext { + @Test + public void testAllFilesPresentInLocalContext() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/localContext"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/parameters") + @TestDataPath("$PROJECT_ROOT") + public class Parameters { + @Test + public void testAllFilesPresentInParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/parameters"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/qualified") + @TestDataPath("$PROJECT_ROOT") + public class Qualified { + @Test + public void testAllFilesPresentInQualified() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/qualified"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/conflictResolution") + @TestDataPath("$PROJECT_ROOT") + public class ConflictResolution { + @Test + public void testAllFilesPresentInConflictResolution() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/conflictResolution"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/fromOtherFile") + @TestDataPath("$PROJECT_ROOT") + public class FromOtherFile { + @Test + public void testAllFilesPresentInFromOtherFile() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/fromOtherFile"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/stdlib") + @TestDataPath("$PROJECT_ROOT") + public class Stdlib { + @Test + public void testAllFilesPresentInStdlib() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/qualified/stdlib"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/thisQualifier") + @TestDataPath("$PROJECT_ROOT") + public class ThisQualifier { + @Test + public void testAllFilesPresentInThisQualifier() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/thisQualifier"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/kDoc/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/kDoc/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/nestedTypes") + @TestDataPath("$PROJECT_ROOT") + public class NestedTypes { + @Test + public void testAllFilesPresentInNestedTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/nestedTypes"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/packageReference") + @TestDataPath("$PROJECT_ROOT") + public class PackageReference { + @Test + public void testAllFilesPresentInPackageReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/packageReference"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/qualifiedAccess") + @TestDataPath("$PROJECT_ROOT") + public class QualifiedAccess { + @Test + public void testAllFilesPresentInQualifiedAccess() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/qualifiedAccess"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeArgument") + @TestDataPath("$PROJECT_ROOT") + public class TypeArgument { + @Test + public void testAllFilesPresentInTypeArgument() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeArgument"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeArgument/constant") + @TestDataPath("$PROJECT_ROOT") + public class Constant { + @Test + public void testAllFilesPresentInConstant() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeArgument/constant"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeArgument/functionCall") + @TestDataPath("$PROJECT_ROOT") + public class FunctionCall { + @Test + public void testAllFilesPresentInFunctionCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeArgument/functionCall"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeArgument/propertyAccess") + @TestDataPath("$PROJECT_ROOT") + public class PropertyAccess { + @Test + public void testAllFilesPresentInPropertyAccess() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeArgument/propertyAccess"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeArgument/type") + @TestDataPath("$PROJECT_ROOT") + public class Type { + @Test + public void testAllFilesPresentInType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeArgument/type"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeParameter") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameter { + @Test + public void testAllFilesPresentInTypeParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeParameter"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/withErrors") + @TestDataPath("$PROJECT_ROOT") + public class WithErrors { + @Test + public void testAllFilesPresentInWithErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/withErrors"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/withErrors/partiallyUnresolvedTypeQualifier") + @TestDataPath("$PROJECT_ROOT") + public class PartiallyUnresolvedTypeQualifier { + @Test + public void testAllFilesPresentInPartiallyUnresolvedTypeQualifier() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/withErrors/partiallyUnresolvedTypeQualifier"), Pattern.compile("^(.+)\\.kts$"), null, true); + } + } + } +} diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/symbols/FirIdeNormalAnalysisScriptSourceModuleSymbolByPsiTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/symbols/FirIdeNormalAnalysisScriptSourceModuleSymbolByPsiTestGenerated.java index 838f23b1793..58fca946366 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/symbols/FirIdeNormalAnalysisScriptSourceModuleSymbolByPsiTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/symbols/FirIdeNormalAnalysisScriptSourceModuleSymbolByPsiTestGenerated.java @@ -46,6 +46,12 @@ public class FirIdeNormalAnalysisScriptSourceModuleSymbolByPsiTestGenerated exte KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/symbolByPsi"), Pattern.compile("^(.+)\\.kts$"), null, true); } + @Test + @TestMetadata("script.kts") + public void testScript() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByPsi/script.kts"); + } + @Nested @TestMetadata("analysis/analysis-api/testData/symbols/symbolByPsi/contextReceivers") @TestDataPath("$PROJECT_ROOT") diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/symbols/FirIdeNormalAnalysisScriptSourceModuleSymbolByReferenceTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/symbols/FirIdeNormalAnalysisScriptSourceModuleSymbolByReferenceTestGenerated.java index 1b06deba47c..3e02693056f 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/symbols/FirIdeNormalAnalysisScriptSourceModuleSymbolByReferenceTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/symbols/FirIdeNormalAnalysisScriptSourceModuleSymbolByReferenceTestGenerated.java @@ -46,6 +46,12 @@ public class FirIdeNormalAnalysisScriptSourceModuleSymbolByReferenceTestGenerate KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/symbolByReference"), Pattern.compile("^(.+)\\.kts$"), null, true); } + @Test + @TestMetadata("scriptResult.kts") + public void testScriptResult() throws Exception { + runTest("analysis/analysis-api/testData/symbols/symbolByReference/scriptResult.kts"); + } + @Nested @TestMetadata("analysis/analysis-api/testData/symbols/symbolByReference/withTestCompilerPluginEnabled") @TestDataPath("$PROJECT_ROOT") 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 index 69e6ee69fef..119c61abc41 100644 --- 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 @@ -6,9 +6,11 @@ package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.containingDeclarationProvider import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.analysis.api.symbols.KtScriptSymbol 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.KtScriptInitializer import org.jetbrains.kotlin.psi.KtVisitorVoid import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.services.TestServices @@ -28,8 +30,13 @@ abstract class AbstractContainingDeclarationProviderByPsiTest : AbstractAnalysis 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" + + if (dcl is KtScriptInitializer) { + testServices.assertions.assertTrue(currentDeclarationSymbol is KtScriptSymbol) + } else { + testServices.assertions.assertEquals(expectedParentDeclarationSymbol, actualParentDeclarationSymbol) { + "Invalid parent declaration for $currentDeclarationSymbol, expected $expectedParentDeclarationSymbol but $actualParentDeclarationSymbol found" + } } currentPath.add(dcl) 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 b452eb18a1d..632724fa9fc 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 @@ -32,6 +32,7 @@ public abstract class KtSymbolProvider : KtAnalysisSessionComponent() { is KtClassInitializer -> getClassInitializerSymbol(psi) is KtDestructuringDeclarationEntry -> getDestructuringDeclarationEntrySymbol(psi) is KtScript -> getScriptSymbol(psi) + is KtScriptInitializer -> getScriptSymbol(psi.containingDeclaration) is KtDestructuringDeclaration -> getDestructuringDeclarationSymbol(psi) else -> error("Cannot build symbol for ${psi::class}") } diff --git a/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/scriptWithResultProperty.kts b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/scriptWithResultProperty.kts new file mode 100644 index 00000000000..4fea1eb0301 --- /dev/null +++ b/analysis/analysis-api/testData/components/containingDeclarationProvider/containingDeclarationByPsi/scriptWithResultProperty.kts @@ -0,0 +1,16 @@ +fun foo() = 42 +val prop = 42 + +class Bar { + fun member() { + + } + + val memberProperty: String + get() { + fun b() = "sre" + return b() + } +} + +foo() \ No newline at end of file diff --git a/analysis/analysis-api/testData/referenceResolve/ScriptResult.kts b/analysis/analysis-api/testData/referenceResolve/ScriptResult.kts new file mode 100644 index 00000000000..f81ed384198 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/ScriptResult.kts @@ -0,0 +1,5 @@ +fun foo() { + `$$result` +} + +42 \ No newline at end of file diff --git a/analysis/analysis-api/testData/referenceResolve/ScriptResult.txt b/analysis/analysis-api/testData/referenceResolve/ScriptResult.txt new file mode 100644 index 00000000000..6d872feecb8 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/ScriptResult.txt @@ -0,0 +1,2 @@ +Resolved to: +0: (in : ) val `$$result`: kotlin.Int diff --git a/analysis/analysis-api/testData/symbols/symbolByPsi/script.kts b/analysis/analysis-api/testData/symbols/symbolByPsi/script.kts new file mode 100644 index 00000000000..7a28985e1ad --- /dev/null +++ b/analysis/analysis-api/testData/symbols/symbolByPsi/script.kts @@ -0,0 +1,17 @@ +// DO_NOT_CHECK_NON_PSI_SYMBOL_RESTORE + +fun foo() { + +} + +val b = 42 + +class C { + fun member() { + + } + + val prop = foo() +} + +foo() \ No newline at end of file diff --git a/analysis/analysis-api/testData/symbols/symbolByPsi/script.pretty.txt b/analysis/analysis-api/testData/symbols/symbolByPsi/script.pretty.txt new file mode 100644 index 00000000000..8b137891791 --- /dev/null +++ b/analysis/analysis-api/testData/symbols/symbolByPsi/script.pretty.txt @@ -0,0 +1 @@ + diff --git a/analysis/analysis-api/testData/symbols/symbolByPsi/script.txt b/analysis/analysis-api/testData/symbols/symbolByPsi/script.txt new file mode 100644 index 00000000000..53adab70584 --- /dev/null +++ b/analysis/analysis-api/testData/symbols/symbolByPsi/script.txt @@ -0,0 +1,266 @@ +KtFunctionSymbol: + annotationsList: [] + callableIdIfNonLocal: /foo + contextReceivers: [] + contractEffects: [] + hasStableParameterNames: true + isActual: false + isBuiltinFunctionInvoke: false + isExpect: false + isExtension: false + isExternal: false + isInfix: false + isInline: false + isOperator: false + isOverride: false + isStatic: false + isSuspend: false + modality: FINAL + name: foo + origin: SOURCE + receiverParameter: null + returnType: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Unit + symbolKind: TOP_LEVEL + typeParameters: [] + valueParameters: [] + visibility: Public + getContainingModule: KtScriptModule "Script script.kts" + deprecationStatus: null + +KtKotlinPropertySymbol: + annotationsList: [] + backingFieldSymbol: KtBackingFieldSymbol: + annotationsList: [] + callableIdIfNonLocal: null + contextReceivers: [] + isExtension: false + name: field + origin: PROPERTY_BACKING_FIELD + owningProperty: KtKotlinPropertySymbol(/b) + receiverParameter: null + returnType: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int + symbolKind: LOCAL + typeParameters: [] + getContainingModule: KtScriptModule "Script script.kts" + deprecationStatus: null + callableIdIfNonLocal: /b + contextReceivers: [] + getter: KtPropertyGetterSymbol: + annotationsList: [] + callableIdIfNonLocal: null + contextReceivers: [] + hasBody: false + hasStableParameterNames: true + isDefault: true + isExtension: false + isInline: false + isOverride: false + modality: FINAL + origin: SOURCE + receiverParameter: null + returnType: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int + symbolKind: ACCESSOR + typeParameters: [] + valueParameters: [] + visibility: Public + getContainingModule: KtScriptModule "Script script.kts" + deprecationStatus: null + hasBackingField: true + hasGetter: true + hasSetter: false + initializer: KtConstantInitializerValue(42) + isActual: false + isConst: false + isDelegatedProperty: false + isExpect: false + isExtension: false + isFromPrimaryConstructor: false + isLateInit: false + isOverride: false + isStatic: false + isVal: true + modality: FINAL + name: b + origin: SOURCE + receiverParameter: null + returnType: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int + setter: null + symbolKind: TOP_LEVEL + typeParameters: [] + visibility: Public + getContainingModule: KtScriptModule "Script script.kts" + deprecationStatus: null + getterDeprecationStatus: null + javaGetterName: getB + javaSetterName: null + setterDeprecationStatus: null + +KtFunctionSymbol: + annotationsList: [] + callableIdIfNonLocal: /C.member + contextReceivers: [] + contractEffects: [] + hasStableParameterNames: true + isActual: false + isBuiltinFunctionInvoke: false + isExpect: false + isExtension: false + isExternal: false + isInfix: false + isInline: false + isOperator: false + isOverride: false + isStatic: false + isSuspend: false + modality: FINAL + name: member + origin: SOURCE + receiverParameter: null + returnType: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Unit + symbolKind: CLASS_MEMBER + typeParameters: [] + valueParameters: [] + visibility: Public + getDispatchReceiver(): KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: C + getContainingModule: KtScriptModule "Script script.kts" + deprecationStatus: null + +KtKotlinPropertySymbol: + annotationsList: [] + backingFieldSymbol: KtBackingFieldSymbol: + annotationsList: [] + callableIdIfNonLocal: null + contextReceivers: [] + isExtension: false + name: field + origin: PROPERTY_BACKING_FIELD + owningProperty: KtKotlinPropertySymbol(/C.prop) + receiverParameter: null + returnType: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Unit + symbolKind: LOCAL + typeParameters: [] + getContainingModule: KtScriptModule "Script script.kts" + deprecationStatus: null + callableIdIfNonLocal: /C.prop + contextReceivers: [] + getter: KtPropertyGetterSymbol: + annotationsList: [] + callableIdIfNonLocal: null + contextReceivers: [] + hasBody: false + hasStableParameterNames: true + isDefault: true + isExtension: false + isInline: false + isOverride: false + modality: FINAL + origin: SOURCE + receiverParameter: null + returnType: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Unit + symbolKind: ACCESSOR + typeParameters: [] + valueParameters: [] + visibility: Public + getDispatchReceiver(): KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: C + getContainingModule: KtScriptModule "Script script.kts" + deprecationStatus: null + hasBackingField: true + hasGetter: true + hasSetter: false + initializer: KtNonConstantInitializerValue(foo()) + isActual: false + isConst: false + isDelegatedProperty: false + isExpect: false + isExtension: false + isFromPrimaryConstructor: false + isLateInit: false + isOverride: false + isStatic: false + isVal: true + modality: FINAL + name: prop + origin: SOURCE + receiverParameter: null + returnType: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Unit + setter: null + symbolKind: CLASS_MEMBER + typeParameters: [] + visibility: Public + getDispatchReceiver(): KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: C + getContainingModule: KtScriptModule "Script script.kts" + deprecationStatus: null + getterDeprecationStatus: null + javaGetterName: getProp + javaSetterName: null + setterDeprecationStatus: null + +KtNamedClassOrObjectSymbol: + annotationsList: [] + classIdIfNonLocal: C + classKind: CLASS + companionObject: null + contextReceivers: [] + isActual: false + isData: false + isExpect: false + isExternal: false + isFun: false + isInline: false + isInner: false + modality: FINAL + name: C + origin: SOURCE + superTypes: [ + KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Any + ] + symbolKind: TOP_LEVEL + typeParameters: [] + visibility: Public + getContainingModule: KtScriptModule "Script script.kts" + annotationApplicableTargets: null + deprecationStatus: null + +KtScriptSymbol: + annotationsList: [] + name: + origin: SOURCE + typeParameters: [] + getContainingModule: KtScriptModule "Script script.kts" + deprecationStatus: null \ No newline at end of file diff --git a/analysis/analysis-api/testData/symbols/symbolByReference/scriptResult.kts b/analysis/analysis-api/testData/symbols/symbolByReference/scriptResult.kts new file mode 100644 index 00000000000..54bcdd08360 --- /dev/null +++ b/analysis/analysis-api/testData/symbols/symbolByReference/scriptResult.kts @@ -0,0 +1,7 @@ +// DO_NOT_CHECK_NON_PSI_SYMBOL_RESTORE + +fun foo() { + `$$result` +} + +42 \ No newline at end of file diff --git a/analysis/analysis-api/testData/symbols/symbolByReference/scriptResult.pretty.txt b/analysis/analysis-api/testData/symbols/symbolByReference/scriptResult.pretty.txt new file mode 100644 index 00000000000..378652adaa1 --- /dev/null +++ b/analysis/analysis-api/testData/symbols/symbolByReference/scriptResult.pretty.txt @@ -0,0 +1 @@ +val `$$result`: kotlin.Int diff --git a/analysis/analysis-api/testData/symbols/symbolByReference/scriptResult.txt b/analysis/analysis-api/testData/symbols/symbolByReference/scriptResult.txt new file mode 100644 index 00000000000..cc565c9e6fc --- /dev/null +++ b/analysis/analysis-api/testData/symbols/symbolByReference/scriptResult.txt @@ -0,0 +1,60 @@ +KtKotlinPropertySymbol: + annotationsList: [] + backingFieldSymbol: null + callableIdIfNonLocal: null + contextReceivers: [] + getter: KtPropertyGetterSymbol: + annotationsList: [] + callableIdIfNonLocal: null + contextReceivers: [] + hasBody: false + hasStableParameterNames: true + isDefault: true + isExtension: false + isInline: false + isOverride: false + modality: FINAL + origin: PLUGIN + receiverParameter: null + returnType: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int + symbolKind: ACCESSOR + typeParameters: [] + valueParameters: [] + visibility: Public + getContainingModule: KtScriptModule "Script scriptResult.kts" + deprecationStatus: null + hasBackingField: true + hasGetter: true + hasSetter: false + initializer: KtConstantInitializerValue(42) + isActual: false + isConst: false + isDelegatedProperty: false + isExpect: false + isExtension: false + isFromPrimaryConstructor: false + isLateInit: false + isOverride: false + isStatic: false + isVal: true + modality: FINAL + name: $$result + origin: PLUGIN + receiverParameter: null + returnType: KtUsualClassType: + annotationsList: [] + ownTypeArguments: [] + type: kotlin/Int + setter: null + symbolKind: TOP_LEVEL + typeParameters: [] + visibility: Public + getContainingModule: KtScriptModule "Script scriptResult.kts" + deprecationStatus: null + getterDeprecationStatus: null + javaGetterName: get$$result + javaSetterName: null + setterDeprecationStatus: null 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 540d476ae72..28d0c953024 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 @@ -67,7 +67,7 @@ import org.jetbrains.kotlin.generators.util.TestGeneratorUtil internal fun AnalysisApiTestGroup.generateAnalysisApiTests() { test( AbstractReferenceResolveTest::class, - filter = testModuleKindIs(TestModuleKind.Source, TestModuleKind.LibrarySource) and + filter = testModuleKindIs(TestModuleKind.Source, TestModuleKind.ScriptSource, TestModuleKind.LibrarySource) and analysisApiModeIs(AnalysisApiMode.Ide, AnalysisApiMode.Standalone), ) { data -> when (data.moduleKind) { @@ -79,6 +79,8 @@ internal fun AnalysisApiTestGroup.generateAnalysisApiTests() { ) } + TestModuleKind.ScriptSource -> model(data, "referenceResolve") + else -> { model("referenceResolve", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME) }