From 8b0eb0488fa96578a7c852555d3e6a435f702624 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Thu, 22 Jun 2023 11:13:14 +0200 Subject: [PATCH] [Analysis API] add method for implicit companion object reference detection Add a new method `isImplicitReferenceToCompanion` to determine if the given reference is an implicit reference to a companion object. The method is needed for the rename refactoring in IJ. ^KTIJ-25863 --- .../KtFe10ReferenceResolveProvider.kt | 12 ++- ...plicitCompanionReferenceTestGenerated.java | 96 +++++++++++++++++++ .../KtFirReferenceResolveProvider.kt | 12 +++ ...plicitCompanionReferenceTestGenerated.java | 96 +++++++++++++++++++ ...plicitCompanionReferenceTestGenerated.java | 96 +++++++++++++++++++ ...bstractIsImplicitCompanionReferenceTest.kt | 36 +++++++ ...plicitCompanionReferenceTestGenerated.java | 96 +++++++++++++++++++ .../api/components/KtReferenceResolveMixIn.kt | 21 ++++ .../components/KtReferenceResolveProvider.kt | 2 + ...sAccessWithExplicitReferenceToCompanion.kt | 9 ++ ...AccessWithExplicitReferenceToCompanion.txt | 1 + ...ssWithExplicitReferenceToNamedCompanion.kt | 9 ++ ...sWithExplicitReferenceToNamedCompanion.txt | 1 + .../constructorCall.kt | 9 ++ .../constructorCall.txt | 1 + .../constructorCallWithInvokeInCompanion.kt | 10 ++ .../constructorCallWithInvokeInCompanion.txt | 1 + .../explicitReferenceToCompanion.kt | 9 ++ .../explicitReferenceToCompanion.txt | 1 + .../explicitReferenceToNamedCompanion.kt | 9 ++ .../explicitReferenceToNamedCompanion.txt | 1 + .../impicitReferenceToCompanion.kt | 8 ++ .../impicitReferenceToCompanion.txt | 1 + .../qualifierReferenceToClassWithCompanion.kt | 8 ++ ...qualifierReferenceToClassWithCompanion.txt | 1 + .../tests/analysis/api/analysisApi.kt | 8 ++ 26 files changed, 553 insertions(+), 1 deletion(-) create mode 100644 analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/referenceResolveProvider/Fe10IdeNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/referenceResolveProvider/FirIdeDependentAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/referenceResolveProvider/FirIdeNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java create mode 100644 analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/referenceResolveProvider/AbstractIsImplicitCompanionReferenceTest.kt create mode 100644 analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/referenceResolveProvider/FirStandaloneNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.kt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.txt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.kt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.txt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.kt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.txt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.kt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.txt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.kt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.txt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.kt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.txt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.kt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.txt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.kt create mode 100644 analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.txt diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ReferenceResolveProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ReferenceResolveProvider.kt index c7c05486b05..07d4716abcf 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ReferenceResolveProvider.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ReferenceResolveProvider.kt @@ -12,10 +12,12 @@ import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnaly import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol import org.jetbrains.kotlin.idea.references.KtReference +import org.jetbrains.kotlin.idea.references.KtSimpleNameReference import org.jetbrains.kotlin.references.fe10.base.KtFe10Reference +import org.jetbrains.kotlin.resolve.BindingContext internal class KtFe10ReferenceResolveProvider( - override val analysisSession: KtFe10AnalysisSession + override val analysisSession: KtFe10AnalysisSession, ) : KtReferenceResolveProvider(), Fe10KtAnalysisSessionComponent { override fun resolveToSymbols(reference: KtReference): Collection { require(reference is KtFe10Reference) @@ -24,4 +26,12 @@ internal class KtFe10ReferenceResolveProvider( descriptor.toKtSymbol(analysisContext) } } + + override fun isImplicitReferenceToCompanion(reference: KtReference): Boolean { + if (reference !is KtSimpleNameReference) { + return false + } + val bindingContext = analysisContext.analyze(reference.element, Fe10AnalysisFacade.AnalysisMode.PARTIAL) + return bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, reference.element] != null + } } \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/referenceResolveProvider/Fe10IdeNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/referenceResolveProvider/Fe10IdeNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java new file mode 100644 index 00000000000..f4dd6fe57e7 --- /dev/null +++ b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/referenceResolveProvider/Fe10IdeNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java @@ -0,0 +1,96 @@ +/* + * 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.fe10.test.cases.generated.cases.components.referenceResolveProvider; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.fe10.test.configurator.AnalysisApiFe10TestConfiguratorFactory; +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.referenceResolveProvider.AbstractIsImplicitCompanionReferenceTest; +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/referenceResolveProvider/isImplicitReferenceToCompanion") +@TestDataPath("$PROJECT_ROOT") +public class Fe10IdeNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated extends AbstractIsImplicitCompanionReferenceTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFe10TestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fe10, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInIsImplicitReferenceToCompanion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("classAccessWithExplicitReferenceToCompanion.kt") + public void testClassAccessWithExplicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("classAccessWithExplicitReferenceToNamedCompanion.kt") + public void testClassAccessWithExplicitReferenceToNamedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.kt"); + } + + @Test + @TestMetadata("constructorCall.kt") + public void testConstructorCall() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.kt"); + } + + @Test + @TestMetadata("constructorCallWithInvokeInCompanion.kt") + public void testConstructorCallWithInvokeInCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.kt"); + } + + @Test + @TestMetadata("explicitReferenceToCompanion.kt") + public void testExplicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("explicitReferenceToNamedCompanion.kt") + public void testExplicitReferenceToNamedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.kt"); + } + + @Test + @TestMetadata("impicitReferenceToCompanion.kt") + public void testImpicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("qualifierReferenceToClassWithCompanion.kt") + public void testQualifierReferenceToClassWithCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.kt"); + } +} diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceResolveProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceResolveProvider.kt index 434b8fd0bdd..60c6c62381e 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceResolveProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceResolveProvider.kt @@ -9,7 +9,10 @@ import org.jetbrains.kotlin.analysis.api.KtSymbolBasedReference import org.jetbrains.kotlin.analysis.api.components.KtReferenceResolveProvider import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirSafe +import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.idea.references.KtReference +import org.jetbrains.kotlin.idea.references.KtSimpleNameReference internal class KtFirReferenceResolveProvider( override val analysisSession: KtFirAnalysisSession @@ -20,4 +23,13 @@ internal class KtFirReferenceResolveProvider( return analysisSession.resolveToSymbols() } } + + override fun isImplicitReferenceToCompanion(reference: KtReference): Boolean { + if (reference !is KtSimpleNameReference) { + return false + } + val referenceElement = reference.element + val qualifier = referenceElement.getOrBuildFirSafe(analysisSession.firResolveSession) ?: return false + return qualifier.resolvedToCompanionObject + } } \ No newline at end of file diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/referenceResolveProvider/FirIdeDependentAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/referenceResolveProvider/FirIdeDependentAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java new file mode 100644 index 00000000000..110986ef0e6 --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/referenceResolveProvider/FirIdeDependentAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java @@ -0,0 +1,96 @@ +/* + * 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.components.referenceResolveProvider; + +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.referenceResolveProvider.AbstractIsImplicitCompanionReferenceTest; +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/referenceResolveProvider/isImplicitReferenceToCompanion") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeDependentAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated extends AbstractIsImplicitCompanionReferenceTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Dependent, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInIsImplicitReferenceToCompanion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("classAccessWithExplicitReferenceToCompanion.kt") + public void testClassAccessWithExplicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("classAccessWithExplicitReferenceToNamedCompanion.kt") + public void testClassAccessWithExplicitReferenceToNamedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.kt"); + } + + @Test + @TestMetadata("constructorCall.kt") + public void testConstructorCall() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.kt"); + } + + @Test + @TestMetadata("constructorCallWithInvokeInCompanion.kt") + public void testConstructorCallWithInvokeInCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.kt"); + } + + @Test + @TestMetadata("explicitReferenceToCompanion.kt") + public void testExplicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("explicitReferenceToNamedCompanion.kt") + public void testExplicitReferenceToNamedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.kt"); + } + + @Test + @TestMetadata("impicitReferenceToCompanion.kt") + public void testImpicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("qualifierReferenceToClassWithCompanion.kt") + public void testQualifierReferenceToClassWithCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.kt"); + } +} diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/referenceResolveProvider/FirIdeNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/referenceResolveProvider/FirIdeNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java new file mode 100644 index 00000000000..54015ca3ba2 --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/referenceResolveProvider/FirIdeNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java @@ -0,0 +1,96 @@ +/* + * 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.components.referenceResolveProvider; + +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.referenceResolveProvider.AbstractIsImplicitCompanionReferenceTest; +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/referenceResolveProvider/isImplicitReferenceToCompanion") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated extends AbstractIsImplicitCompanionReferenceTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInIsImplicitReferenceToCompanion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("classAccessWithExplicitReferenceToCompanion.kt") + public void testClassAccessWithExplicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("classAccessWithExplicitReferenceToNamedCompanion.kt") + public void testClassAccessWithExplicitReferenceToNamedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.kt"); + } + + @Test + @TestMetadata("constructorCall.kt") + public void testConstructorCall() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.kt"); + } + + @Test + @TestMetadata("constructorCallWithInvokeInCompanion.kt") + public void testConstructorCallWithInvokeInCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.kt"); + } + + @Test + @TestMetadata("explicitReferenceToCompanion.kt") + public void testExplicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("explicitReferenceToNamedCompanion.kt") + public void testExplicitReferenceToNamedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.kt"); + } + + @Test + @TestMetadata("impicitReferenceToCompanion.kt") + public void testImpicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("qualifierReferenceToClassWithCompanion.kt") + public void testQualifierReferenceToClassWithCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.kt"); + } +} diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/referenceResolveProvider/AbstractIsImplicitCompanionReferenceTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/referenceResolveProvider/AbstractIsImplicitCompanionReferenceTest.kt new file mode 100644 index 00000000000..e6165b414aa --- /dev/null +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/referenceResolveProvider/AbstractIsImplicitCompanionReferenceTest.kt @@ -0,0 +1,36 @@ +/* + * 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.impl.base.test.cases.components.referenceResolveProvider + +import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest +import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider +import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction +import org.jetbrains.kotlin.idea.references.KtReference +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.psi.KtNameReferenceExpression +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.assertions + +abstract class AbstractIsImplicitCompanionReferenceTest : AbstractAnalysisApiSingleFileTest() { + + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + val referenceExpression = testServices.expressionMarkerProvider.getElementOfTypeAtCaret(ktFile) + + val isImplicitCompanionReference = executeOnPooledThreadInReadAction { + analyseForTest(referenceExpression) { + val reference = referenceExpression.reference as KtReference + reference.isImplicitReferenceToCompanion() + } + } + + val actual = buildString { + append("isImplicitCompanionReference: $isImplicitCompanionReference") + } + + testServices.assertions.assertEqualsToTestDataFileSibling(actual) + } +} diff --git a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/referenceResolveProvider/FirStandaloneNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/referenceResolveProvider/FirStandaloneNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java new file mode 100644 index 00000000000..bcc20d8458c --- /dev/null +++ b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/referenceResolveProvider/FirStandaloneNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated.java @@ -0,0 +1,96 @@ +/* + * 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.standalone.fir.test.cases.generated.cases.components.referenceResolveProvider; + +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.referenceResolveProvider.AbstractIsImplicitCompanionReferenceTest; +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/referenceResolveProvider/isImplicitReferenceToCompanion") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleIsImplicitCompanionReferenceTestGenerated extends AbstractIsImplicitCompanionReferenceTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInIsImplicitReferenceToCompanion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("classAccessWithExplicitReferenceToCompanion.kt") + public void testClassAccessWithExplicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("classAccessWithExplicitReferenceToNamedCompanion.kt") + public void testClassAccessWithExplicitReferenceToNamedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.kt"); + } + + @Test + @TestMetadata("constructorCall.kt") + public void testConstructorCall() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.kt"); + } + + @Test + @TestMetadata("constructorCallWithInvokeInCompanion.kt") + public void testConstructorCallWithInvokeInCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.kt"); + } + + @Test + @TestMetadata("explicitReferenceToCompanion.kt") + public void testExplicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("explicitReferenceToNamedCompanion.kt") + public void testExplicitReferenceToNamedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.kt"); + } + + @Test + @TestMetadata("impicitReferenceToCompanion.kt") + public void testImpicitReferenceToCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.kt"); + } + + @Test + @TestMetadata("qualifierReferenceToClassWithCompanion.kt") + public void testQualifierReferenceToClassWithCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.kt"); + } +} diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtReferenceResolveMixIn.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtReferenceResolveMixIn.kt index 66a9c7f3bc5..d75e806609d 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtReferenceResolveMixIn.kt +++ b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtReferenceResolveMixIn.kt @@ -17,4 +17,25 @@ public interface KtReferenceResolveMixIn : KtAnalysisSessionMixIn { public fun KtReference.resolveToSymbol(): KtSymbol? = withValidityAssertion { return resolveToSymbols().singleOrNull() } + + /** + * Checks if the reference is an implicit reference to a companion object via the containing class. + * + * Example: + * ``` + * class A { + * companion object { + * fun foo() {} + * } + * } + * ``` + * + * For the case provided, inside the call `A.foo()`, + * the `A` is an implicit reference to the companion object, so `isImplicitReferenceToCompanion` returns `true` + * + * @return `true` if the reference is an implicit reference to a companion object, `false` otherwise. + */ + public fun KtReference.isImplicitReferenceToCompanion(): Boolean = withValidityAssertion { + analysisSession.referenceResolveProvider.isImplicitReferenceToCompanion(this) + } } \ No newline at end of file diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtReferenceResolveProvider.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtReferenceResolveProvider.kt index a203c224898..d4f53b03512 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtReferenceResolveProvider.kt +++ b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtReferenceResolveProvider.kt @@ -10,4 +10,6 @@ import org.jetbrains.kotlin.idea.references.KtReference public abstract class KtReferenceResolveProvider { public abstract fun resolveToSymbols(reference: KtReference): Collection + + public abstract fun isImplicitReferenceToCompanion(reference: KtReference): Boolean } \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.kt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.kt new file mode 100644 index 00000000000..80eb203ddfa --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.kt @@ -0,0 +1,9 @@ +class AA { + companion object { + fun x() = 10 + } +} +fun main() { + AA.Companion.x() +} + diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.txt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.txt new file mode 100644 index 00000000000..b138e4e298d --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToCompanion.txt @@ -0,0 +1 @@ +isImplicitCompanionReference: false diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.kt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.kt new file mode 100644 index 00000000000..e5f32c4adc0 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.kt @@ -0,0 +1,9 @@ +class AA { + companion object BB { + fun x() = 10 + } +} +fun main() { + AA.BB.x() +} + diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.txt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.txt new file mode 100644 index 00000000000..ffa91202516 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/classAccessWithExplicitReferenceToNamedCompanion.txt @@ -0,0 +1 @@ +isImplicitCompanionReference: false \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.kt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.kt new file mode 100644 index 00000000000..131445f33db --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.kt @@ -0,0 +1,9 @@ +class AA { + companion object { + fun x() = 10 + } +} +fun main() { + AA() +} + diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.txt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.txt new file mode 100644 index 00000000000..b138e4e298d --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCall.txt @@ -0,0 +1 @@ +isImplicitCompanionReference: false diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.kt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.kt new file mode 100644 index 00000000000..835a9737456 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.kt @@ -0,0 +1,10 @@ +class AA { + companion object { + operator fun invoke() {} + } +} + +fun main() { + AA() +} + diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.txt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.txt new file mode 100644 index 00000000000..b138e4e298d --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/constructorCallWithInvokeInCompanion.txt @@ -0,0 +1 @@ +isImplicitCompanionReference: false diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.kt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.kt new file mode 100644 index 00000000000..bb67db951c5 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.kt @@ -0,0 +1,9 @@ +class AA { + companion object { + fun x() = 10 + } +} +fun main() { + AA.Companion.x() +} + diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.txt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.txt new file mode 100644 index 00000000000..b138e4e298d --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToCompanion.txt @@ -0,0 +1 @@ +isImplicitCompanionReference: false diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.kt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.kt new file mode 100644 index 00000000000..c4eb9fa93ae --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.kt @@ -0,0 +1,9 @@ +class AA { + companion object BB { + fun x() = 10 + } +} +fun main() { + AA.BB.x() +} + diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.txt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.txt new file mode 100644 index 00000000000..b138e4e298d --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/explicitReferenceToNamedCompanion.txt @@ -0,0 +1 @@ +isImplicitCompanionReference: false diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.kt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.kt new file mode 100644 index 00000000000..6989e3c5193 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.kt @@ -0,0 +1,8 @@ +class AA { + companion object { + fun x() = 10 + } +} +fun main() { + AA.x() +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.txt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.txt new file mode 100644 index 00000000000..ea3d0e72fb2 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/impicitReferenceToCompanion.txt @@ -0,0 +1 @@ +isImplicitCompanionReference: true diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.kt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.kt new file mode 100644 index 00000000000..b9db1861e13 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.kt @@ -0,0 +1,8 @@ +class AA { + companion object { + fun x() = 10 + } +} +fun main() { + AA +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.txt b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.txt new file mode 100644 index 00000000000..ea3d0e72fb2 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceResolveProvider/isImplicitReferenceToCompanion/qualifierReferenceToClassWithCompanion.txt @@ -0,0 +1 @@ +isImplicitCompanionReference: true 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 e58e467bfb7..b29d68ee517 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 @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.importO import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.multiplatformInfoProvider.AbstractExpectForActualTest import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.psiTypeProvider.AbstractAnalysisApiExpressionPsiTypeProviderTest import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.psiTypeProvider.AbstractAnalysisApiPsiTypeProviderTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.referenceResolveProvider.AbstractIsImplicitCompanionReferenceTest import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.scopeProvider.* import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.signatureSubstitution.AbstractAnalysisApiSignatureContractsTest import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.signatureSubstitution.AbstractAnalysisApiSignatureSubstitutionTest @@ -391,6 +392,13 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { } } + + component("referenceResolveProvider") { + test(AbstractIsImplicitCompanionReferenceTest::class) { + model("isImplicitReferenceToCompanion") + } + } + component("scopeProvider") { group(filter = frontendIs(FrontendKind.Fir)) { test(AbstractTypeScopeTest::class) {