From da385210d8130799a74820a1b6f7cf0a1807b632 Mon Sep 17 00:00:00 2001 From: Anna Kozlova Date: Thu, 5 Oct 2023 15:18:55 +0000 Subject: [PATCH] [AA] provide psiType#asKtType conversion it's useful for IDE's features such as write UAST or refactorings ^KT-62302 fixed Merge-request: KT-MR-12414 Merged-by: Anna Kozlova --- .../components/KtFe10PsiTypeProvider.kt | 9 ++ .../fir/components/KtFirPsiTypeProvider.kt | 74 +++++++++++++- ...iKtTypeByPsiTypeProviderTestGenerated.java | 48 ++++++++++ ...iKtTypeByPsiTypeProviderTestGenerated.java | 96 +++++++++++++++++++ ...iKtTypeByPsiTypeProviderTestGenerated.java | 48 ++++++++++ ...iKtTypeByPsiTypeProviderTestGenerated.java | 96 +++++++++++++++++++ ...tAnalysisApiKtTypeByPsiTypeProviderTest.kt | 47 +++++++++ ...iKtTypeByPsiTypeProviderTestGenerated.java | 96 +++++++++++++++++++ .../api/components/KtPsiTypeProvider.kt | 15 +++ .../psiType/asKtType/anonym.kt | 11 +++ .../psiType/asKtType/anonym.txt | 2 + .../psiType/asKtType/extends.kt | 8 ++ .../psiType/asKtType/extends.txt | 2 + .../psiType/asKtType/methodTypeParameters.kt | 10 ++ .../psiType/asKtType/methodTypeParameters.txt | 2 + .../psiType/asKtType/nestedGenerics.kt | 8 ++ .../psiType/asKtType/nestedGenerics.txt | 2 + .../psiType/asKtType/nullableString.kt | 8 ++ .../psiType/asKtType/nullableString.txt | 2 + .../psiType/asKtType/primitive.kt | 8 ++ .../psiType/asKtType/primitive.txt | 2 + .../psiType/asKtType/typeParameters.kt | 8 ++ .../psiType/asKtType/typeParameters.txt | 2 + .../psiType/asKtType/typeParameters2.kt | 13 +++ .../psiType/asKtType/typeParameters2.txt | 2 + .../tests/analysis/api/analysisApi.kt | 5 + 26 files changed, 623 insertions(+), 1 deletion(-) create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeDependentAnalysisScriptSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeDependentAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeNormalAnalysisScriptSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java create mode 100644 analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeNormalAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java create mode 100644 analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiKtTypeByPsiTypeProviderTest.kt create mode 100644 analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/anonym.kt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/anonym.txt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/extends.kt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/extends.txt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/methodTypeParameters.kt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/methodTypeParameters.txt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nestedGenerics.kt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nestedGenerics.txt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nullableString.kt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nullableString.txt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/primitive.kt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/primitive.txt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters.kt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters.txt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters2.kt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters2.txt diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10PsiTypeProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10PsiTypeProvider.kt index a1b45f6238b..5dd199307bb 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10PsiTypeProvider.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10PsiTypeProvider.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components import com.intellij.psi.PsiElement +import com.intellij.psi.PsiType import com.intellij.psi.PsiTypeElement import com.intellij.psi.impl.cache.TypeInfo import com.intellij.psi.impl.compiled.ClsTypeElementImpl @@ -28,6 +29,7 @@ import org.jetbrains.kotlin.platform.has import org.jetbrains.kotlin.platform.jvm.JvmPlatform import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.model.SimpleTypeMarker +import java.lang.UnsupportedOperationException import java.text.StringCharacterIterator internal class KtFe10PsiTypeProvider( @@ -106,4 +108,11 @@ internal class KtFe10PsiTypeProvider( return ClsTypeElementImpl(useSitePosition, typeText, '\u0000') } + + override fun asKtType( + psiType: PsiType, + useSitePosition: PsiElement, + ): KtType? { + throw UnsupportedOperationException("Conversion to KtType is not supported in K1 implementation") + } } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirPsiTypeProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirPsiTypeProvider.kt index b721530519b..56ec51b8700 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirPsiTypeProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirPsiTypeProvider.kt @@ -11,9 +11,11 @@ import com.intellij.psi.impl.cache.TypeInfo import com.intellij.psi.impl.compiled.ClsTypeElementImpl import com.intellij.psi.impl.compiled.SignatureParsing import com.intellij.psi.impl.compiled.StubBuildingVisitor -import java.text.StringCharacterIterator +import com.intellij.psi.util.PsiTreeUtil +import com.intellij.psi.util.PsiUtil import org.jetbrains.kotlin.analysis.api.components.KtPsiTypeProvider import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession +import org.jetbrains.kotlin.analysis.api.fir.findPsi import org.jetbrains.kotlin.analysis.api.fir.types.KtFirType import org.jetbrains.kotlin.analysis.api.fir.types.PublicTypeApproximator import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken @@ -29,16 +31,27 @@ import org.jetbrains.kotlin.descriptors.java.JavaVisibilities import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.backend.jvm.jvmTypeMapper import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack +import org.jetbrains.kotlin.fir.java.javaSymbolProvider +import org.jetbrains.kotlin.fir.java.resolveIfJavaType import org.jetbrains.kotlin.fir.moduleData import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.substitution.AbstractConeSubstitutor import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.types.jvm.buildJavaTypeRef +import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl +import org.jetbrains.kotlin.load.java.structure.impl.JavaTypeImpl +import org.jetbrains.kotlin.load.java.structure.impl.JavaTypeParameterImpl +import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementSourceFactory import org.jetbrains.kotlin.load.kotlin.TypeMappingMode import org.jetbrains.kotlin.load.kotlin.getOptimalModeForReturnType import org.jetbrains.kotlin.load.kotlin.getOptimalModeForValueParameter +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.SpecialNames import org.jetbrains.kotlin.platform.has import org.jetbrains.kotlin.platform.jvm.JvmPlatform @@ -46,6 +59,7 @@ import org.jetbrains.kotlin.psi import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.psiUtil.parents import org.jetbrains.kotlin.types.model.SimpleTypeMarker +import java.text.StringCharacterIterator internal class KtFirPsiTypeProvider( override val analysisSession: KtFirAnalysisSession, @@ -92,6 +106,64 @@ internal class KtFirPsiTypeProvider( } } } + + override fun asKtType( + psiType: PsiType, + useSitePosition: PsiElement, + ): KtType? { + val javaElementSourceFactory = JavaElementSourceFactory.getInstance(project) + val javaType = JavaTypeImpl.create(psiType, javaElementSourceFactory.createTypeSource(psiType)) + + val javaTypeRef = buildJavaTypeRef { + //TODO KT-62351 + annotationBuilder = { emptyList() } + type = javaType + } + + + val javaTypeParameterStack = JavaTypeParameterStack() + + var psiClass = PsiTreeUtil.getContextOfType(useSitePosition, PsiClass::class.java, false) + while (psiClass != null && psiClass.name == null) { + psiClass = PsiTreeUtil.getContextOfType(psiClass, PsiClass::class.java, true) + } + if (psiClass != null) { + val qualifiedName = psiClass.qualifiedName + val packageName = (psiClass.containingFile as? PsiJavaFile)?.packageName ?: "" + if (qualifiedName != null) { + val javaClass = JavaClassImpl(javaElementSourceFactory.createPsiSource(psiClass)) + val relativeName = if (packageName.isEmpty()) qualifiedName else qualifiedName.substring(packageName.length + 1) + val containingClassSymbol = rootModuleSession.javaSymbolProvider?.getClassLikeSymbolByClassId( + ClassId( + FqName(packageName), + FqName(relativeName.takeIf { !relativeName.isEmpty() } ?: SpecialNames.NO_NAME_PROVIDED.asString()), + PsiUtil.isLocalClass(psiClass) + ), + javaClass + ) + if (containingClassSymbol != null) { + val member = + PsiTreeUtil.getContextOfType(useSitePosition, PsiTypeParameterListOwner::class.java, false, PsiClass::class.java) + if (member != null) { + val memberSymbol = containingClassSymbol.declarationSymbols.find { it.findPsi() == member } as? FirCallableSymbol<*> + if (memberSymbol != null) { + //typeParamSymbol.fir.source == null thus zip is required, see KT-62354 + memberSymbol.typeParameterSymbols.zip(member.typeParameters).forEach { (typeParamSymbol, typeParam) -> + javaTypeParameterStack.addParameter(JavaTypeParameterImpl(typeParam), typeParamSymbol) + } + } + } + + containingClassSymbol.typeParameterSymbols.zip(psiClass.typeParameters).forEach { (symbol, typeParameter) -> + javaTypeParameterStack.addParameter(JavaTypeParameterImpl(typeParameter), symbol) + } + } + } + } + val firTypeRef = javaTypeRef.resolveIfJavaType(analysisSession.useSiteSession, javaTypeParameterStack) + val coneKotlinType = (firTypeRef as? FirResolvedTypeRef)?.type ?: return null + return coneKotlinType.asKtType() + } } private fun ConeKotlinType.simplifyType( diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeDependentAnalysisScriptSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeDependentAnalysisScriptSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java new file mode 100644 index 00000000000..0007c8a06c1 --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeDependentAnalysisScriptSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.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.psiTypeProvider; + +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.psiTypeProvider.AbstractAnalysisApiKtTypeByPsiTypeProviderTest; +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/psiTypeProvider/psiType/asKtType") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeDependentAnalysisScriptSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated extends AbstractAnalysisApiKtTypeByPsiTypeProviderTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.ScriptSource, + AnalysisSessionMode.Dependent, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInAsKtType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType"), 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/psiTypeProvider/FirIdeDependentAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeDependentAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java new file mode 100644 index 00000000000..2982a1ecb56 --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeDependentAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.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.psiTypeProvider; + +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.psiTypeProvider.AbstractAnalysisApiKtTypeByPsiTypeProviderTest; +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/psiTypeProvider/psiType/asKtType") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeDependentAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated extends AbstractAnalysisApiKtTypeByPsiTypeProviderTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Dependent, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInAsKtType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("anonym.kt") + public void testAnonym() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/anonym.kt"); + } + + @Test + @TestMetadata("extends.kt") + public void testExtends() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/extends.kt"); + } + + @Test + @TestMetadata("methodTypeParameters.kt") + public void testMethodTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/methodTypeParameters.kt"); + } + + @Test + @TestMetadata("nestedGenerics.kt") + public void testNestedGenerics() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nestedGenerics.kt"); + } + + @Test + @TestMetadata("nullableString.kt") + public void testNullableString() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nullableString.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/primitive.kt"); + } + + @Test + @TestMetadata("typeParameters.kt") + public void testTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters.kt"); + } + + @Test + @TestMetadata("typeParameters2.kt") + public void testTypeParameters2() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters2.kt"); + } +} diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeNormalAnalysisScriptSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeNormalAnalysisScriptSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java new file mode 100644 index 00000000000..e6d230eaae8 --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeNormalAnalysisScriptSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.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.psiTypeProvider; + +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.psiTypeProvider.AbstractAnalysisApiKtTypeByPsiTypeProviderTest; +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/psiTypeProvider/psiType/asKtType") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeNormalAnalysisScriptSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated extends AbstractAnalysisApiKtTypeByPsiTypeProviderTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.ScriptSource, + AnalysisSessionMode.Normal, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInAsKtType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType"), 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/psiTypeProvider/FirIdeNormalAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeNormalAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java new file mode 100644 index 00000000000..86caf5e9788 --- /dev/null +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/psiTypeProvider/FirIdeNormalAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.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.psiTypeProvider; + +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.psiTypeProvider.AbstractAnalysisApiKtTypeByPsiTypeProviderTest; +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/psiTypeProvider/psiType/asKtType") +@TestDataPath("$PROJECT_ROOT") +public class FirIdeNormalAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated extends AbstractAnalysisApiKtTypeByPsiTypeProviderTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Ide + ) + ); + } + + @Test + public void testAllFilesPresentInAsKtType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("anonym.kt") + public void testAnonym() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/anonym.kt"); + } + + @Test + @TestMetadata("extends.kt") + public void testExtends() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/extends.kt"); + } + + @Test + @TestMetadata("methodTypeParameters.kt") + public void testMethodTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/methodTypeParameters.kt"); + } + + @Test + @TestMetadata("nestedGenerics.kt") + public void testNestedGenerics() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nestedGenerics.kt"); + } + + @Test + @TestMetadata("nullableString.kt") + public void testNullableString() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nullableString.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/primitive.kt"); + } + + @Test + @TestMetadata("typeParameters.kt") + public void testTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters.kt"); + } + + @Test + @TestMetadata("typeParameters2.kt") + public void testTypeParameters2() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters2.kt"); + } +} diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiKtTypeByPsiTypeProviderTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiKtTypeByPsiTypeProviderTest.kt new file mode 100644 index 00000000000..c85c4fdb68f --- /dev/null +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiKtTypeByPsiTypeProviderTest.kt @@ -0,0 +1,47 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.psiTypeProvider + +import com.intellij.psi.PsiJavaFile +import com.intellij.psi.PsiMethod +import com.intellij.psi.util.PsiTreeUtil +import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedTest +import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider +import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider +import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.services.TestModuleStructure +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.assertions +import org.jetbrains.kotlin.types.Variance +import org.jetbrains.kotlin.util.PrivateForInline + +abstract class AbstractAnalysisApiKtTypeByPsiTypeProviderTest : AbstractAnalysisApiBasedTest() { + @OptIn(PrivateForInline::class) + override fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) { + val ktFile = moduleStructure.modules.map { testServices.ktModuleProvider.getModuleFiles(it).filterIsInstance().first() }.first() + val psiMethod = moduleStructure.modules.map { module -> + val psiFiles = testServices.ktModuleProvider.getModuleFiles(module).filterIsInstance() + val javaFile = psiFiles.first() + val offset = testServices.expressionMarkerProvider.carets.getCaretOffset(javaFile.name, null)!! + PsiTreeUtil.getParentOfType(javaFile.findElementAt(offset), PsiMethod::class.java) + }.single()!! + + val actual = buildString { + executeOnPooledThreadInReadAction { + analyseForTest(ktFile) { + val returnType = psiMethod.returnType + testServices.assertions.assertNotNull(returnType) + val asKtTypeSuper = returnType!!.asKtType(psiMethod)!! + appendLine("PsiType: $returnType") + appendLine("KtType: ${asKtTypeSuper.render(position = Variance.OUT_VARIANCE)}") + } + } + } + + 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/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.java new file mode 100644 index 00000000000..f371fb7b045 --- /dev/null +++ b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/psiTypeProvider/FirStandaloneNormalAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated.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.psiTypeProvider; + +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.psiTypeProvider.AbstractAnalysisApiKtTypeByPsiTypeProviderTest; +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/psiTypeProvider/psiType/asKtType") +@TestDataPath("$PROJECT_ROOT") +public class FirStandaloneNormalAnalysisSourceModuleAnalysisApiKtTypeByPsiTypeProviderTestGenerated extends AbstractAnalysisApiKtTypeByPsiTypeProviderTest { + @NotNull + @Override + public AnalysisApiTestConfigurator getConfigurator() { + return AnalysisApiFirStandaloneModeTestConfiguratorFactory.INSTANCE.createConfigurator( + new AnalysisApiTestConfiguratorFactoryData( + FrontendKind.Fir, + TestModuleKind.Source, + AnalysisSessionMode.Normal, + AnalysisApiMode.Standalone + ) + ); + } + + @Test + public void testAllFilesPresentInAsKtType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("anonym.kt") + public void testAnonym() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/anonym.kt"); + } + + @Test + @TestMetadata("extends.kt") + public void testExtends() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/extends.kt"); + } + + @Test + @TestMetadata("methodTypeParameters.kt") + public void testMethodTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/methodTypeParameters.kt"); + } + + @Test + @TestMetadata("nestedGenerics.kt") + public void testNestedGenerics() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nestedGenerics.kt"); + } + + @Test + @TestMetadata("nullableString.kt") + public void testNullableString() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nullableString.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/primitive.kt"); + } + + @Test + @TestMetadata("typeParameters.kt") + public void testTypeParameters() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters.kt"); + } + + @Test + @TestMetadata("typeParameters2.kt") + public void testTypeParameters2() throws Exception { + runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters2.kt"); + } +} diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtPsiTypeProvider.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtPsiTypeProvider.kt index 4ee81bc5fb0..a026c4162ef 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtPsiTypeProvider.kt +++ b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtPsiTypeProvider.kt @@ -20,6 +20,11 @@ public abstract class KtPsiTypeProvider : KtAnalysisSessionComponent() { isAnnotationMethod: Boolean, allowErrorTypes: Boolean ): PsiTypeElement? + + public abstract fun asKtType( + psiType: PsiType, + useSitePosition: PsiElement + ): KtType? } public interface KtPsiTypeProviderMixIn : KtAnalysisSessionMixIn { @@ -68,4 +73,14 @@ public interface KtPsiTypeProviderMixIn : KtAnalysisSessionMixIn { isAnnotationMethod: Boolean = false ): PsiType? = asPsiTypeElement(useSitePosition, allowErrorTypes, mode, isAnnotationMethod)?.type + + /** + * Converts given [PsiType] to [KtType]. + * + * @receiver PsiType to be converted. + * @return The converted KtType, or null if conversion is not possible e.g., [PsiType] is not resolved + */ + public fun PsiType.asKtType(useSitePosition: PsiElement): KtType? = withValidityAssertion { + analysisSession.psiTypeProvider.asKtType(this, useSitePosition) + } } diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/anonym.kt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/anonym.kt new file mode 100644 index 00000000000..daae4bb7fc6 --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/anonym.kt @@ -0,0 +1,11 @@ +// FILE: B.kt +class AK: A() { +} +// FILE: A.java +class A { + A a = new A<>() { + T foo() { + + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/anonym.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/anonym.txt new file mode 100644 index 00000000000..3aef682c854 --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/anonym.txt @@ -0,0 +1,2 @@ +PsiType: PsiType:T +KtType: T? diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/extends.kt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/extends.kt new file mode 100644 index 00000000000..8f8dd6a1475 --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/extends.kt @@ -0,0 +1,8 @@ +// FILE: B.kt +interface B: A { + fun foo(): java.util.List? +} +// FILE: A.java +public interface A { + java.util.List foo(); +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/extends.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/extends.txt new file mode 100644 index 00000000000..83c872dcba5 --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/extends.txt @@ -0,0 +1,2 @@ +PsiType: PsiType:List +KtType: kotlin.collections.List? diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/methodTypeParameters.kt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/methodTypeParameters.kt new file mode 100644 index 00000000000..83d0dabbdd9 --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/methodTypeParameters.kt @@ -0,0 +1,10 @@ +// FILE: B.kt +class B: A { + override fun foo(): K? { + TODO("Not yet implemented") + } +} +// FILE: A.java +public interface A { + K foo(); +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/methodTypeParameters.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/methodTypeParameters.txt new file mode 100644 index 00000000000..cbb5b24b87b --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/methodTypeParameters.txt @@ -0,0 +1,2 @@ +PsiType: PsiType:K +KtType: K? diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nestedGenerics.kt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nestedGenerics.kt new file mode 100644 index 00000000000..23a59e700ac --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nestedGenerics.kt @@ -0,0 +1,8 @@ +// FILE: B.kt +interface B: A { + fun foo(): java.util.List? +} +// FILE: A.java +public interface A { + java.util.List foo(); +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nestedGenerics.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nestedGenerics.txt new file mode 100644 index 00000000000..b7d7a6f78c0 --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nestedGenerics.txt @@ -0,0 +1,2 @@ +PsiType: PsiType:List +KtType: kotlin.collections.List? diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nullableString.kt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nullableString.kt new file mode 100644 index 00000000000..5c6ca9ba5de --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nullableString.kt @@ -0,0 +1,8 @@ +// FILE: B.kt +interface B: A { + fun foo(): String? +} +// FILE: A.java +public interface A { + String foo(); +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nullableString.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nullableString.txt new file mode 100644 index 00000000000..f011d4bdd1d --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/nullableString.txt @@ -0,0 +1,2 @@ +PsiType: PsiType:String +KtType: kotlin.String? diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/primitive.kt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/primitive.kt new file mode 100644 index 00000000000..391a70e1ef5 --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/primitive.kt @@ -0,0 +1,8 @@ +// FILE: B.kt +interface B: A { + fun foo(): Int +} +// FILE: A.java +public interface A { + int foo(); +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/primitive.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/primitive.txt new file mode 100644 index 00000000000..07c41f381dc --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/primitive.txt @@ -0,0 +1,2 @@ +PsiType: PsiType:int +KtType: kotlin.Int diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters.kt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters.kt new file mode 100644 index 00000000000..ce245d58ca5 --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters.kt @@ -0,0 +1,8 @@ +// FILE: B.kt +interface B: A { + fun foo(): String? +} +// FILE: A.java +public interface A { + T foo(); +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters.txt new file mode 100644 index 00000000000..3aef682c854 --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters.txt @@ -0,0 +1,2 @@ +PsiType: PsiType:T +KtType: T? diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters2.kt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters2.kt new file mode 100644 index 00000000000..e520f9a719f --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters2.kt @@ -0,0 +1,13 @@ +// FILE: B.kt +class AK: A() { + inner class BK: B() { + override fun foo(): K { + } + } +} +// FILE: A.java +class A { + abstract class B { + abstract K foo(); + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters2.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters2.txt new file mode 100644 index 00000000000..cbb5b24b87b --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/asKtType/typeParameters2.txt @@ -0,0 +1,2 @@ +PsiType: PsiType:K +KtType: K? 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 a7dece8c952..092f3ead22c 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 @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.express import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.importOptimizer.AbstractAnalysisApiImportOptimizerTest 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.AbstractAnalysisApiKtTypeByPsiTypeProviderTest 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.resolveExtensionInfoProvider.AbstractResolveExtensionInfoProviderTest @@ -336,6 +337,10 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { test(AbstractAnalysisApiExpressionPsiTypeProviderTest::class, filter = frontendIs(FrontendKind.Fir)) { model(it, "psiType/forExpression") } + + test(AbstractAnalysisApiKtTypeByPsiTypeProviderTest::class, filter = frontendIs(FrontendKind.Fir)){ + model(it, "psiType/asKtType") + } } component("resolveExtensionInfoProvider", filter = frontendIs(FrontendKind.Fir)) {