From 96575a0bdb9c34f6e41c06693c8a1a7482cdc3ff Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Thu, 14 Mar 2024 18:31:58 +0100 Subject: [PATCH] [Analysis API FIR] preserve type annotations on asPsiType conversion ^KT-66603 Fixed --- .../components/KtFe10PsiTypeProvider.kt | 19 +++++- analysis/analysis-api-fir/build.gradle.kts | 2 +- .../fir/components/KtFirPsiTypeProvider.kt | 42 +++++++++++-- .../api/components/KtPsiTypeProvider.kt | 61 +++++++++++++------ .../nestedTypeAnnotation.descriptors.txt | 2 + .../forDeclaration/nestedTypeAnnotation.txt | 2 +- .../typeAnnotation.descriptors.txt | 2 + .../psiType/forDeclaration/typeAnnotation.txt | 2 +- .../wildcardSuppression_false.txt | 2 +- .../wildcardSuppression_true.txt | 2 +- .../annotations/symbolAnnotationsUtils.kt | 6 +- .../symbol/methods/SymbolLightSimpleMethod.kt | 4 +- .../parameters/SymbolLightParameterCommon.kt | 2 + .../SymbolLightParameterForReceiver.kt | 5 +- .../light/classes/symbol/symbolLightUtils.kt | 9 ++- .../NestedTypeAnnotations.java | 4 +- .../jvmWildcardAnnotations.java | 10 +-- .../lightClassByPsi/typeAnnotations.java | 8 +-- 18 files changed, 136 insertions(+), 48 deletions(-) create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/nestedTypeAnnotation.descriptors.txt create mode 100644 analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/typeAnnotation.descriptors.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 d6a836571a5..c0167fee7ba 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 @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 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. */ @@ -65,6 +65,23 @@ internal class KtFe10PsiTypeProvider( ) } + override fun asPsiType( + type: KtType, + useSitePosition: PsiElement, + allowErrorTypes: Boolean, + mode: KtTypeMappingMode, + isAnnotationMethod: Boolean, + suppressWildcards: Boolean?, + preserveAnnotations: Boolean + ): PsiType? = asPsiTypeElement( + type = type, + useSitePosition = useSitePosition, + mode = mode, + isAnnotationMethod = isAnnotationMethod, + suppressWildcards = suppressWildcards, + allowErrorTypes = allowErrorTypes, + )?.type + private fun KtTypeMappingMode.toTypeMappingMode( type: KtType, isAnnotationMethod: Boolean, diff --git a/analysis/analysis-api-fir/build.gradle.kts b/analysis/analysis-api-fir/build.gradle.kts index a820b7c3168..c94a9d2266a 100644 --- a/analysis/analysis-api-fir/build.gradle.kts +++ b/analysis/analysis-api-fir/build.gradle.kts @@ -33,6 +33,7 @@ dependencies { implementation(project(":analysis:analysis-api-providers")) implementation(project(":analysis:analysis-internal-utils")) implementation(project(":analysis:kt-references")) + implementation(project(":analysis:symbol-light-classes")) testImplementation(projectTests(":analysis:low-level-api-fir")) testImplementation(project(":analysis:analysis-api-standalone:analysis-api-standalone-base")) @@ -53,7 +54,6 @@ dependencies { testApi(platform(libs.junit.bom)) testImplementation(libs.junit.jupiter.api) testRuntimeOnly(libs.junit.jupiter.engine) - testImplementation(project(":analysis:symbol-light-classes")) } sourceSets { 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 c6e2d9c6d66..7fbfc422db7 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 @@ -13,6 +13,7 @@ import com.intellij.psi.impl.compiled.SignatureParsing import com.intellij.psi.impl.compiled.StubBuildingVisitor import com.intellij.psi.util.PsiTreeUtil import com.intellij.psi.util.PsiUtil +import org.jetbrains.kotlin.analysis.api.KtAnalysisNonPublicApi import org.jetbrains.kotlin.analysis.api.components.KtPsiTypeProvider import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession import org.jetbrains.kotlin.analysis.api.fir.findPsi @@ -43,6 +44,7 @@ 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.light.classes.symbol.annotations.annotateByKtType 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 @@ -96,6 +98,38 @@ internal class KtFirPsiTypeProvider( ) } + override fun asPsiType( + type: KtType, + useSitePosition: PsiElement, + allowErrorTypes: Boolean, + mode: KtTypeMappingMode, + isAnnotationMethod: Boolean, + suppressWildcards: Boolean?, + preserveAnnotations: Boolean, + ): PsiType? { + val typeElement = asPsiTypeElement( + type = type, + useSitePosition = useSitePosition, + mode = mode, + isAnnotationMethod = isAnnotationMethod, + suppressWildcards = suppressWildcards, + allowErrorTypes = allowErrorTypes, + ) ?: return null + + val psiType = typeElement.type + if (!preserveAnnotations) return psiType + + @OptIn(KtAnalysisNonPublicApi::class) + return with(analysisSession) { + annotateByKtType( + psiType = psiType, + ktType = type, + psiContext = typeElement, + modifierListAsParent = null, + ) + } + } + private fun KtTypeMappingMode.toTypeMappingMode( type: KtType, isAnnotationMethod: Boolean, @@ -195,7 +229,7 @@ internal class KtFirPsiTypeProvider( private fun ConeKotlinType.simplifyType( session: FirSession, useSitePosition: PsiElement, - visited: MutableSet = mutableSetOf() + visited: MutableSet = mutableSetOf(), ): ConeKotlinType { // E.g., Wrapper : Comparable> if (!visited.add(this)) return this @@ -235,7 +269,7 @@ private fun ConeKotlinType.needLocalTypeApproximation( visibilityForApproximation: Visibility, isInlineFunction: Boolean, session: FirSession, - useSitePosition: PsiElement + useSitePosition: PsiElement, ): Boolean { if (!shouldApproximateAnonymousTypesOfNonLocalDeclaration(visibilityForApproximation, isInlineFunction)) return false val localTypes: List = if (isLocal(session)) listOf(this) else { @@ -309,7 +343,7 @@ private fun ConeKotlinType.asPsiTypeElement( session: FirSession, mode: TypeMappingMode, useSitePosition: PsiElement, - allowErrorTypes: Boolean + allowErrorTypes: Boolean, ): PsiTypeElement? { if (this !is SimpleTypeMarker) return null @@ -373,7 +407,7 @@ private class AnonymousTypesSubstitutor( } private fun ConeKotlinType.hasRecursiveTypeArgument( - visited: MutableSet = mutableSetOf() + visited: MutableSet = mutableSetOf(), ): Boolean { if (typeArguments.isEmpty()) return false if (!visited.add(this)) return true 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 557f7406a44..7235ac6c01a 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 @@ -22,6 +22,16 @@ public abstract class KtPsiTypeProvider : KtAnalysisSessionComponent() { allowErrorTypes: Boolean, ): PsiTypeElement? + public abstract fun asPsiType( + type: KtType, + useSitePosition: PsiElement, + allowErrorTypes: Boolean, + mode: KtTypeMappingMode, + isAnnotationMethod: Boolean, + suppressWildcards: Boolean?, + preserveAnnotations: Boolean, + ): PsiType? + public abstract fun asKtType( psiType: PsiType, useSitePosition: PsiElement @@ -54,6 +64,10 @@ public interface KtPsiTypeProviderMixIn : KtAnalysisSessionMixIn { * `null` is no-op by default, i.e., their suppression/appearance is determined by type annotations. * * Note: [PsiTypeElement] is JVM conception, so this method will return `null` for non-JVM platforms. + * + * @return [PsiTypeElement] without type annotations if mapping is successful + * + * @see asPsiType */ public fun KtType.asPsiTypeElement( useSitePosition: PsiElement, @@ -63,23 +77,30 @@ public interface KtPsiTypeProviderMixIn : KtAnalysisSessionMixIn { suppressWildcards: Boolean? = null, ): PsiTypeElement? = withValidityAssertion { analysisSession.psiTypeProvider.asPsiTypeElement( - this, - useSitePosition, - mode, - isAnnotationMethod, - suppressWildcards, - allowErrorTypes, + type = this, + useSitePosition = useSitePosition, + mode = mode, + isAnnotationMethod = isAnnotationMethod, + suppressWildcards = suppressWildcards, + allowErrorTypes = allowErrorTypes, ) } /** * Converts the given [KtType] to [PsiType] under [useSitePosition] context. * - * This simply unwraps [PsiTypeElement] returned from [asPsiTypeElement]. - * Use this version if type annotation is not required. Otherwise, use [asPsiTypeElement] to get [PsiTypeElement] as an owner of - * annotations on [PsiType] and annotate the resulting [PsiType] with proper [PsiAnnotation][com.intellij.psi.PsiAnnotation]. - * * Note: [PsiType] is JVM conception, so this method will return `null` for non-JVM platforms. + * + * @receiver type to convert + * + * @param useSitePosition is used to determine if the given [KtType] needs to be approximated. + * For instance, if the given type is local yet available in the same scope of use site, + * we can still use such a local type. + * Otherwise, e.g., exposed to public as a return type, the resulting type will be approximated accordingly. + * + * @param allowErrorTypes if **false** the result will be null in the case of an error type inside the [type][this] + * + * @param preserveAnnotations if **true** the result [PsiType] will have converted annotations from the original [type][this] */ public fun KtType.asPsiType( useSitePosition: PsiElement, @@ -87,14 +108,18 @@ public interface KtPsiTypeProviderMixIn : KtAnalysisSessionMixIn { mode: KtTypeMappingMode = KtTypeMappingMode.DEFAULT, isAnnotationMethod: Boolean = false, suppressWildcards: Boolean? = null, - ): PsiType? = - asPsiTypeElement( - useSitePosition, - allowErrorTypes, - mode, - isAnnotationMethod, - suppressWildcards, - )?.type + preserveAnnotations: Boolean = true, + ): PsiType? = withValidityAssertion { + analysisSession.psiTypeProvider.asPsiType( + type = this, + useSitePosition = useSitePosition, + allowErrorTypes = allowErrorTypes, + mode = mode, + isAnnotationMethod = isAnnotationMethod, + suppressWildcards = suppressWildcards, + preserveAnnotations = preserveAnnotations, + ) + } /** * Converts given [PsiType] to [KtType]. diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/nestedTypeAnnotation.descriptors.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/nestedTypeAnnotation.descriptors.txt new file mode 100644 index 00000000000..db52b1267a1 --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/nestedTypeAnnotation.descriptors.txt @@ -0,0 +1,2 @@ +KtType: @foo.MyAnno(s = "outer") kotlin.collections.List<@foo.MyAnno(s = "middle") kotlin.collections.List<@foo.AnotherAnnotation(k = foo.Nested::class) kotlin.String>> +PsiType: java.util.List> diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/nestedTypeAnnotation.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/nestedTypeAnnotation.txt index db52b1267a1..6bf5ffdb783 100644 --- a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/nestedTypeAnnotation.txt +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/nestedTypeAnnotation.txt @@ -1,2 +1,2 @@ KtType: @foo.MyAnno(s = "outer") kotlin.collections.List<@foo.MyAnno(s = "middle") kotlin.collections.List<@foo.AnotherAnnotation(k = foo.Nested::class) kotlin.String>> -PsiType: java.util.List> +PsiType: java.util.@foo.MyAnno("outer") List<@foo.MyAnno("middle") ? extends java.util.List> diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/typeAnnotation.descriptors.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/typeAnnotation.descriptors.txt new file mode 100644 index 00000000000..316716540b2 --- /dev/null +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/typeAnnotation.descriptors.txt @@ -0,0 +1,2 @@ +KtType: @foo.MyAnno(s = "str1") kotlin.String +PsiType: java.lang.String diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/typeAnnotation.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/typeAnnotation.txt index 316716540b2..7baa82dabef 100644 --- a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/typeAnnotation.txt +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/typeAnnotation.txt @@ -1,2 +1,2 @@ KtType: @foo.MyAnno(s = "str1") kotlin.String -PsiType: java.lang.String +PsiType: java.lang.@foo.MyAnno("str" + "1") String diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/wildcardSuppression_false.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/wildcardSuppression_false.txt index 7b25f40fa6e..084f441fa87 100644 --- a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/wildcardSuppression_false.txt +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/wildcardSuppression_false.txt @@ -1,2 +1,2 @@ KtType: @kotlin.jvm.JvmSuppressWildcards(suppress = false) (AnimatedContentTransitionScope.() -> EnterTransition?)? -PsiType: kotlin.jvm.functions.Function1,? extends EnterTransition> +PsiType: kotlin.jvm.functions.@kotlin.jvm.JvmSuppressWildcards(suppress = false) Function1,? extends EnterTransition> diff --git a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/wildcardSuppression_true.txt b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/wildcardSuppression_true.txt index 6a3c729a86f..2499b921500 100644 --- a/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/wildcardSuppression_true.txt +++ b/analysis/analysis-api/testData/components/psiTypeProvider/psiType/forDeclaration/wildcardSuppression_true.txt @@ -1,2 +1,2 @@ KtType: @kotlin.jvm.JvmSuppressWildcards(suppress = true) (AnimatedContentTransitionScope.() -> EnterTransition?)? -PsiType: kotlin.jvm.functions.Function1,EnterTransition> +PsiType: kotlin.jvm.functions.@kotlin.jvm.JvmSuppressWildcards(suppress = true) Function1,EnterTransition> diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/symbolAnnotationsUtils.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/symbolAnnotationsUtils.kt index 38735cf2f1c..cb85f88db4a 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/symbolAnnotationsUtils.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/symbolAnnotationsUtils.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 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. */ @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.light.classes.symbol.annotations import com.intellij.psi.* import com.intellij.psi.impl.light.LightReferenceListBuilder +import org.jetbrains.kotlin.analysis.api.KtAnalysisNonPublicApi import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.annotations.* import org.jetbrains.kotlin.analysis.api.annotations.KtKClassAnnotationValue.KtNonLocalKClassAnnotationValue @@ -161,7 +162,8 @@ internal fun KtAnnotatedSymbol.computeThrowsList( } context(KtAnalysisSession) -internal fun annotateByKtType( +@KtAnalysisNonPublicApi +fun annotateByKtType( psiType: PsiType, ktType: KtType, psiContext: PsiTypeElement, diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightSimpleMethod.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightSimpleMethod.kt index 38384404e9e..e46425f2bb7 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightSimpleMethod.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightSimpleMethod.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 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. */ @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.light.classes.symbol.methods import com.intellij.psi.* import kotlinx.collections.immutable.PersistentMap import kotlinx.collections.immutable.mutate +import org.jetbrains.kotlin.analysis.api.KtAnalysisNonPublicApi import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.annotations.hasAnnotation import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol @@ -236,6 +237,7 @@ internal class SymbolLightSimpleMethod( this@SymbolLightSimpleMethod.containingClass.isAnnotationType, suppressWildcards = suppressWildcards(), )?.let { + @OptIn(KtAnalysisNonPublicApi::class) annotateByKtType(it.type, ktType, it, modifierList) } } ?: nonExistentType() diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameterCommon.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameterCommon.kt index 57c8e23ea1c..aa4e95f96ad 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameterCommon.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameterCommon.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.light.classes.symbol.parameters import com.intellij.psi.* +import org.jetbrains.kotlin.analysis.api.KtAnalysisNonPublicApi import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer @@ -84,6 +85,7 @@ internal abstract class SymbolLightParameterCommon( ktType.typeMappingMode(), suppressWildcards = parameterSymbol.suppressWildcardMode(), )?.let { + @OptIn(KtAnalysisNonPublicApi::class) annotateByKtType(it.type, ktType, it, modifierList) } } ?: nonExistentType() diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameterForReceiver.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameterForReceiver.kt index 00ed9ba6352..32ce1c8e931 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameterForReceiver.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameterForReceiver.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 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. */ @@ -9,6 +9,7 @@ import com.intellij.psi.PsiIdentifier import com.intellij.psi.PsiModifierList import com.intellij.psi.PsiType import com.intellij.psi.util.TypeConversionUtil +import org.jetbrains.kotlin.analysis.api.KtAnalysisNonPublicApi import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtReceiverParameterSymbol @@ -93,8 +94,10 @@ internal class SymbolLightParameterForReceiver private constructor( ktType.typeMappingMode(), suppressWildcards = receiver.suppressWildcard() ?: method.suppressWildcards(), )?.let { + @OptIn(KtAnalysisNonPublicApi::class) annotateByKtType(it.type, ktType, it, modifierList) } + if (method is SymbolLightAnnotationsMethod) { val erased = TypeConversionUtil.erasure(psiType) val name = erased.canonicalText diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/symbolLightUtils.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/symbolLightUtils.kt index 40f1f73d444..e53f802dfc7 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/symbolLightUtils.kt +++ b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/symbolLightUtils.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 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. */ @@ -51,14 +51,13 @@ internal fun KtAnalysisSession.mapType( psiContext: PsiElement, mode: KtTypeMappingMode ): PsiClassType? { - val psiTypeElement = type.asPsiTypeElement( + val psiType = type.asPsiType( psiContext, allowErrorTypes = true, mode, ) - return (psiTypeElement?.type as? PsiClassType)?.let { - annotateByKtType(it, type, psiTypeElement, modifierListAsParent = null) as? PsiClassType - } + + return psiType as? PsiClassType } internal enum class NullabilityType { diff --git a/compiler/testData/asJava/lightClasses/lightClassByFqName/NestedTypeAnnotations.java b/compiler/testData/asJava/lightClasses/lightClassByFqName/NestedTypeAnnotations.java index e095d9e77bb..8b48b1f0437 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByFqName/NestedTypeAnnotations.java +++ b/compiler/testData/asJava/lightClasses/lightClassByFqName/NestedTypeAnnotations.java @@ -1,12 +1,12 @@ public final class Nested /* foo.Nested*/ { @org.jetbrains.annotations.Nullable() - private java.util.List> property = null /* initializer type: null */; + private @foo.MyAnno(s = "outer") java.util.List<@foo.MyAnno(s = "middle") ? extends java.util.List> property = null /* initializer type: null */; @org.jetbrains.annotations.Nullable() public final @foo.MyAnno(s = "outer") java.util.List<@foo.MyAnno(s = "middle") java.util.List<@foo.AnotherAnnotation(k = foo.Nested.class) java.lang.String>> function(@org.jetbrains.annotations.NotNull() @foo.MyAnno(s = "outer") java.util.List<@foo.MyAnno(s = "middle") ? extends java.util.List>, @org.jetbrains.annotations.NotNull() @foo.MyAnno(s = "outer") java.util.List<@foo.MyAnno(s = "middle") ? extends java.util.List>);// function(@foo.MyAnno(s = "outer") java.util.List<@foo.MyAnno(s = "middle") ? extends java.util.List>, @foo.MyAnno(s = "outer") java.util.List<@foo.MyAnno(s = "middle") ? extends java.util.List>) @org.jetbrains.annotations.Nullable() - public final java.util.List> getProperty();// getProperty() + public final @foo.MyAnno(s = "outer") java.util.List<@foo.MyAnno(s = "middle") java.util.List<@foo.AnotherAnnotation(k = foo.Nested.class) java.lang.String>> getProperty();// getProperty() public Nested();// .ctor() diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.java index 19a2f1b1c2d..ff4ee1b3dcc 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.java +++ b/compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.java @@ -45,22 +45,22 @@ public final class ContainerForPropertyAndAccessors /* ContainerForPropertyAndAc private Out bar; @org.jetbrains.annotations.NotNull() - private final In simpleIn; + private final In<@kotlin.jvm.JvmWildcard() ? super java.lang.Object> simpleIn; @org.jetbrains.annotations.NotNull() - private final Out simpleOut; + private final Out<@kotlin.jvm.JvmWildcard() ? extends Final> simpleOut; @org.jetbrains.annotations.NotNull() private final Out>> deepOpen; @org.jetbrains.annotations.NotNull() - public final In getSimpleIn();// getSimpleIn() + public final @kotlin.jvm.JvmSuppressWildcards(suppress = false) Out getZoo(@org.jetbrains.annotations.NotNull() Out>>);// getZoo(Out>>) @org.jetbrains.annotations.NotNull() - public final Out getSimpleOut();// getSimpleOut() + public final In<@kotlin.jvm.JvmWildcard() ? super java.lang.Object> getSimpleIn();// getSimpleIn() @org.jetbrains.annotations.NotNull() - public final Out getZoo(@org.jetbrains.annotations.NotNull() Out>>);// getZoo(Out>>) + public final Out<@kotlin.jvm.JvmWildcard() ? extends Final> getSimpleOut();// getSimpleOut() @org.jetbrains.annotations.NotNull() public final Out getBar();// getBar() diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/typeAnnotations.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/typeAnnotations.java index d90725f5d66..563325eaa75 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/typeAnnotations.java +++ b/compiler/testData/asJava/lightClasses/lightClassByPsi/typeAnnotations.java @@ -53,17 +53,17 @@ public final class Y /* Y*/ { public final class klass /* klass*/ { @org.jetbrains.annotations.Nullable() - private final java.util.List y = null /* initializer type: null */; + private final java.util.List<@A0() java.lang.Integer> y = null /* initializer type: null */; - private final int x = 2 /* initializer type: int */; + private final @A0() int x = 2 /* initializer type: int */; @org.jetbrains.annotations.NotNull() public final @A6() X annotatedMethod(@org.jetbrains.annotations.NotNull() @A0() P<@A1() X, P<@A2() @A3() X, @A4() Y>>, @org.jetbrains.annotations.NotNull() @A5() Y[]);// annotatedMethod(@A0() P<@A1() X, P<@A2() @A3() X, @A4() Y>>, @A5() Y[]) @org.jetbrains.annotations.Nullable() - public final java.util.List getY();// getY() + public final java.util.List<@A0() java.lang.Integer> getY();// getY() public klass();// .ctor() - public final int getX();// getX() + public final @A0() int getX();// getX() }