From 4110a9971a8f94a1a7a6ce39dd3a8572f4be48b5 Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Sun, 5 Nov 2023 23:27:28 -0800 Subject: [PATCH] AA: fix KtTypeProvider#getReceiverTypeForDoubleColonExpression K1 version has used a wrong expression to retrieve the slice. K2 version mishandled property access as a receiver. ^KT-63195 fixed --- .../components/KtFe10TypeProvider.kt | 2 +- ...eDoubleColonReceiverTypeTestGenerated.java | 78 +++++++++++++++++++ .../api/fir/components/KtFirTypeProvider.kt | 16 +++- ...eDoubleColonReceiverTypeTestGenerated.java | 48 ++++++++++++ ...eDoubleColonReceiverTypeTestGenerated.java | 78 +++++++++++++++++++ ...eDoubleColonReceiverTypeTestGenerated.java | 48 ++++++++++++ ...eDoubleColonReceiverTypeTestGenerated.java | 78 +++++++++++++++++++ .../AbstractDoubleColonReceiverTypeTest.kt | 34 ++++++++ .../AbstractFunctionClassKindTest.kt | 2 +- ...eDoubleColonReceiverTypeTestGenerated.java | 78 +++++++++++++++++++ .../getClass_primitive.kt | 1 + .../getClass_primitive.txt | 2 + .../doubleColonReceiverType/getClass_type.kt | 3 + .../doubleColonReceiverType/getClass_type.txt | 2 + .../getClass_variable.kt | 3 + .../getClass_variable.txt | 2 + .../methodReference_type.kt | 1 + .../methodReference_type.txt | 2 + .../methodReference_variable.kt | 1 + .../methodReference_variable.txt | 2 + .../tests/analysis/api/analysisApi.kt | 4 + 21 files changed, 479 insertions(+), 6 deletions(-) create mode 100644 analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/typeInfoProvider/Fe10IdeNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeDependentAnalysisScriptSourceModuleDoubleColonReceiverTypeTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeDependentAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeNormalAnalysisScriptSourceModuleDoubleColonReceiverTypeTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java create mode 100644 analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractDoubleColonReceiverTypeTest.kt create mode 100644 analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java create mode 100644 analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.kt create mode 100644 analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.txt create mode 100644 analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.kt create mode 100644 analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.txt create mode 100644 analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.kt create mode 100644 analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.txt create mode 100644 analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.kt create mode 100644 analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.txt create mode 100644 analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.kt create mode 100644 analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.txt diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeProvider.kt index 3900273628a..28b8d15746e 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeProvider.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeProvider.kt @@ -114,7 +114,7 @@ internal class KtFe10TypeProvider( override fun getReceiverTypeForDoubleColonExpression(expression: KtDoubleColonExpression): KtType? { val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL) - val lhs = bindingContext[BindingContext.DOUBLE_COLON_LHS, expression] ?: return null + val lhs = bindingContext[BindingContext.DOUBLE_COLON_LHS, expression.receiverExpression] ?: return null return lhs.type.toKtType(analysisContext) } diff --git a/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/typeInfoProvider/Fe10IdeNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/typeInfoProvider/Fe10IdeNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java new file mode 100644 index 00000000000..b33a6204982 --- /dev/null +++ b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/typeInfoProvider/Fe10IdeNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java @@ -0,0 +1,78 @@ +/* + * 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.typeInfoProvider; + +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.typeInfoProvider.AbstractDoubleColonReceiverTypeTest; +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/typeInfoProvider/doubleColonReceiverType") +@TestDataPath("$PROJECT_ROOT") +public class Fe10IdeNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated extends AbstractDoubleColonReceiverTypeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFe10TestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fe10, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInDoubleColonReceiverType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("getClass_primitive.kt") + public void testGetClass_primitive() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.kt"); + } + + @Test + @TestMetadata("getClass_type.kt") + public void testGetClass_type() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.kt"); + } + + @Test + @TestMetadata("getClass_variable.kt") + public void testGetClass_variable() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.kt"); + } + + @Test + @TestMetadata("methodReference_type.kt") + public void testMethodReference_type() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.kt"); + } + + @Test + @TestMetadata("methodReference_variable.kt") + public void testMethodReference_variable() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.kt"); + } +} diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt index b1a8a8c96b9..3f5d4bdb064 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt @@ -34,6 +34,7 @@ import org.jetbrains.kotlin.fir.declarations.fullyExpandedClass import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirGetClassCall +import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression import org.jetbrains.kotlin.fir.psi import org.jetbrains.kotlin.fir.renderer.FirRenderer import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap @@ -173,11 +174,18 @@ internal class KtFirTypeProvider( override fun getReceiverTypeForDoubleColonExpression(expression: KtDoubleColonExpression): KtType? { return when (val fir = expression.getOrBuildFir(firResolveSession)) { - is FirGetClassCall -> + is FirGetClassCall -> { fir.resolvedType.getReceiverOfReflectionType()?.asKtType() - is FirCallableReferenceAccess -> - fir.resolvedType.getReceiverOfReflectionType()?.asKtType() - else -> throwUnexpectedFirElementError(fir, expression) + } + is FirCallableReferenceAccess -> { + when (val explicitReceiver = fir.explicitReceiver) { + is FirPropertyAccessExpression -> explicitReceiver.resolvedType.asKtType() + else -> fir.resolvedType.getReceiverOfReflectionType()?.asKtType() + } + } + else -> { + throwUnexpectedFirElementError(fir, expression) + } } } diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeDependentAnalysisScriptSourceModuleDoubleColonReceiverTypeTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeDependentAnalysisScriptSourceModuleDoubleColonReceiverTypeTestGenerated.java new file mode 100644 index 00000000000..5792ac25804 --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeDependentAnalysisScriptSourceModuleDoubleColonReceiverTypeTestGenerated.java @@ -0,0 +1,48 @@ +/* + * 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.typeInfoProvider; + +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.typeInfoProvider.AbstractDoubleColonReceiverTypeTest; +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/typeInfoProvider/doubleColonReceiverType") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeDependentAnalysisScriptSourceModuleDoubleColonReceiverTypeTestGenerated extends AbstractDoubleColonReceiverTypeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.ScriptSource, + AnalysisSessionMode.Dependent, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInDoubleColonReceiverType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType"), Pattern.compile("^(.+)\\.kts$"), null, true); + } +} diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeDependentAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeDependentAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java new file mode 100644 index 00000000000..bbcd7562456 --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeDependentAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java @@ -0,0 +1,78 @@ +/* + * 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.typeInfoProvider; + +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.typeInfoProvider.AbstractDoubleColonReceiverTypeTest; +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/typeInfoProvider/doubleColonReceiverType") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeDependentAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated extends AbstractDoubleColonReceiverTypeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Dependent, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInDoubleColonReceiverType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("getClass_primitive.kt") + public void testGetClass_primitive() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.kt"); + } + + @Test + @TestMetadata("getClass_type.kt") + public void testGetClass_type() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.kt"); + } + + @Test + @TestMetadata("getClass_variable.kt") + public void testGetClass_variable() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.kt"); + } + + @Test + @TestMetadata("methodReference_type.kt") + public void testMethodReference_type() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.kt"); + } + + @Test + @TestMetadata("methodReference_variable.kt") + public void testMethodReference_variable() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.kt"); + } +} diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeNormalAnalysisScriptSourceModuleDoubleColonReceiverTypeTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeNormalAnalysisScriptSourceModuleDoubleColonReceiverTypeTestGenerated.java new file mode 100644 index 00000000000..7a8b2f2f7bb --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeNormalAnalysisScriptSourceModuleDoubleColonReceiverTypeTestGenerated.java @@ -0,0 +1,48 @@ +/* + * 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.typeInfoProvider; + +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.typeInfoProvider.AbstractDoubleColonReceiverTypeTest; +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/typeInfoProvider/doubleColonReceiverType") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeNormalAnalysisScriptSourceModuleDoubleColonReceiverTypeTestGenerated extends AbstractDoubleColonReceiverTypeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.ScriptSource, + AnalysisSessionMode.Normal, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInDoubleColonReceiverType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType"), Pattern.compile("^(.+)\\.kts$"), null, true); + } +} diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java new file mode 100644 index 00000000000..07f7dcdf0a6 --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/typeInfoProvider/FirIdeNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java @@ -0,0 +1,78 @@ +/* + * 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.typeInfoProvider; + +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.typeInfoProvider.AbstractDoubleColonReceiverTypeTest; +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/typeInfoProvider/doubleColonReceiverType") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated extends AbstractDoubleColonReceiverTypeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInDoubleColonReceiverType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("getClass_primitive.kt") + public void testGetClass_primitive() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.kt"); + } + + @Test + @TestMetadata("getClass_type.kt") + public void testGetClass_type() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.kt"); + } + + @Test + @TestMetadata("getClass_variable.kt") + public void testGetClass_variable() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.kt"); + } + + @Test + @TestMetadata("methodReference_type.kt") + public void testMethodReference_type() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.kt"); + } + + @Test + @TestMetadata("methodReference_variable.kt") + public void testMethodReference_variable() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.kt"); + } +} diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractDoubleColonReceiverTypeTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractDoubleColonReceiverTypeTest.kt new file mode 100644 index 00000000000..a3d798c5eb4 --- /dev/null +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractDoubleColonReceiverTypeTest.kt @@ -0,0 +1,34 @@ +/* + * 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.typeInfoProvider + +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.psi.KtDoubleColonExpression +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.assertions +import org.jetbrains.kotlin.types.Variance + +abstract class AbstractDoubleColonReceiverTypeTest : AbstractAnalysisApiSingleFileTest() { + override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { + val expressionAtCaret = testServices.expressionMarkerProvider.getElementOfTypeAtCaret(ktFile) as KtDoubleColonExpression + + val type = executeOnPooledThreadInReadAction { + analyseForTest(expressionAtCaret) { + expressionAtCaret.getReceiverKtType()?.render(position = Variance.INVARIANT) + } + } + + val actual = buildString { + appendLine("expression: ${expressionAtCaret.text}") + appendLine("receiver:: type: $type") + } + testServices.assertions.assertEqualsToTestDataFileSibling(actual) + } +} diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractFunctionClassKindTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractFunctionClassKindTest.kt index 85009028431..b5e353b0385 100644 --- a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractFunctionClassKindTest.kt +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractFunctionClassKindTest.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.test.services.TestServices import org.jetbrains.kotlin.test.services.assertions import org.jetbrains.kotlin.types.Variance -abstract class AbstractFunctionClassKindTest : AbstractAnalysisApiSingleFileTest() { +abstract class AbstractFunctionClassKindTest : AbstractAnalysisApiSingleFileTest() { override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) { val expressionAtCaret = testServices.expressionMarkerProvider.getElementOfTypeAtCaret(ktFile) as KtExpression diff --git a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java new file mode 100644 index 00000000000..b567fcbcdca --- /dev/null +++ b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/typeInfoProvider/FirStandaloneNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated.java @@ -0,0 +1,78 @@ +/* + * 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.typeInfoProvider; + +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.typeInfoProvider.AbstractDoubleColonReceiverTypeTest; +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/typeInfoProvider/doubleColonReceiverType") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleDoubleColonReceiverTypeTestGenerated extends AbstractDoubleColonReceiverTypeTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInDoubleColonReceiverType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("getClass_primitive.kt") + public void testGetClass_primitive() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.kt"); + } + + @Test + @TestMetadata("getClass_type.kt") + public void testGetClass_type() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.kt"); + } + + @Test + @TestMetadata("getClass_variable.kt") + public void testGetClass_variable() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.kt"); + } + + @Test + @TestMetadata("methodReference_type.kt") + public void testMethodReference_type() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.kt"); + } + + @Test + @TestMetadata("methodReference_variable.kt") + public void testMethodReference_variable() throws Exception { + runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.kt"); + } +} diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.kt b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.kt new file mode 100644 index 00000000000..7df19923ea1 --- /dev/null +++ b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.kt @@ -0,0 +1 @@ +fun test() = Int::class diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.txt b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.txt new file mode 100644 index 00000000000..ad0b72ad87a --- /dev/null +++ b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_primitive.txt @@ -0,0 +1,2 @@ +expression: Int::class +receiver:: type: kotlin.Int diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.kt b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.kt new file mode 100644 index 00000000000..c9a98b6268b --- /dev/null +++ b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.kt @@ -0,0 +1,3 @@ +interface MyInterface + +fun test() = MyInterface::class diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.txt b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.txt new file mode 100644 index 00000000000..2012b1b6f09 --- /dev/null +++ b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.txt @@ -0,0 +1,2 @@ +expression: MyInterface::class +receiver:: type: MyInterface diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.kt b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.kt new file mode 100644 index 00000000000..a634392edfa --- /dev/null +++ b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.kt @@ -0,0 +1,3 @@ +interface MyInterface + +fun test(x: MyInterface) = x::class diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.txt b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.txt new file mode 100644 index 00000000000..1fc62eaba5e --- /dev/null +++ b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_variable.txt @@ -0,0 +1,2 @@ +expression: x::class +receiver:: type: MyInterface diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.kt b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.kt new file mode 100644 index 00000000000..cb7e1e4845c --- /dev/null +++ b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.kt @@ -0,0 +1 @@ +fun test() = Number::toInt diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.txt b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.txt new file mode 100644 index 00000000000..3dfc29a202a --- /dev/null +++ b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_type.txt @@ -0,0 +1,2 @@ +expression: Number::toInt +receiver:: type: kotlin.Number diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.kt b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.kt new file mode 100644 index 00000000000..de6f8e8181b --- /dev/null +++ b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.kt @@ -0,0 +1 @@ +fun test(a: Number) = a::toInt diff --git a/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.txt b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.txt new file mode 100644 index 00000000000..8f5041e7687 --- /dev/null +++ b/analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/methodReference_variable.txt @@ -0,0 +1,2 @@ +expression: a::toInt +receiver:: type: kotlin.Number 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 b2bfeba9cf9..3d7652b207b 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 @@ -45,6 +45,7 @@ import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.symbolD import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.symbolInfoProvider.AbstractAnnotationApplicableTargetsTest import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.typeCreator.AbstractBuildClassTypeTest import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.typeCreator.AbstractTypeParameterTypeTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.typeInfoProvider.AbstractDoubleColonReceiverTypeTest import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.typeInfoProvider.AbstractFunctionClassKindTest import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.typeInfoProvider.AbstractIsDenotableTest import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.typeProvider.AbstractAnalysisApiGetSuperTypesTest @@ -416,6 +417,9 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { test(AbstractAnalysisApiGetSuperTypesTest::class, filter = frontendIs(FrontendKind.Fir)) { model(it, "superTypes") } + test(AbstractDoubleColonReceiverTypeTest::class) { + model(it, "doubleColonReceiverType") + } test(AbstractIsDenotableTest::class) { model(it, "isDenotable", excludedPattern = ".*\\.descriptors\\.kt$") }