From 41ea0e8ef86037116326863d112fb378bba348f5 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Tue, 4 Jul 2017 15:21:52 +0300 Subject: [PATCH] Introduce AnnotationDescriptor.fqName Could be used instead of ".annotationClass.fqName" to avoid the unneeded resolution of the annotation class descriptor --- .../extensions/AnnotationBasedExtension.kt | 7 +++-- .../checkers/DslScopeViolationCallChecker.kt | 3 +-- .../kotlin/ir/declarations/IrFile.kt | 6 ----- .../asJava/elements/KtLightModifierList.kt | 4 +-- .../LazyJavaAnnotationDescriptor.kt | 5 ++-- .../typeEnhancement/signatureEnhancement.kt | 6 ++--- .../annotations/AnnotationDescriptor.kt | 7 +++++ .../annotations/AnnotationDescriptorImpl.java | 8 ++++++ .../descriptors/annotations/Annotations.kt | 21 +++++---------- .../annotations/AnnotationsImpl.kt | 7 +---- .../kotlin/renderer/DescriptorRendererImpl.kt | 12 ++------- .../descriptors/DeserializedAnnotations.kt | 9 ++----- .../inspections/UnusedSymbolInspection.kt | 16 +++--------- .../migration/MigrateExternalExtensionFix.kt | 3 +-- .../KotlinAnnotatedElementsSearcher.kt | 6 ++--- .../resolve/diagnostics/JsQualifierChecker.kt | 4 +-- .../js/translate/utils/AnnotationsUtils.java | 26 ++++--------------- .../kotlin/declarations/KotlinUAnnotation.kt | 3 +-- 18 files changed, 48 insertions(+), 105 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/extensions/AnnotationBasedExtension.kt b/compiler/frontend/src/org/jetbrains/kotlin/extensions/AnnotationBasedExtension.kt index ed1f0990d57..8b8e8a90c35 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/extensions/AnnotationBasedExtension.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/extensions/AnnotationBasedExtension.kt @@ -21,7 +21,6 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.psi.KtModifierListOwner import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.types.TypeUtils interface AnnotationBasedExtension { @@ -45,14 +44,14 @@ interface AnnotationBasedExtension { visitedAnnotations: MutableSet = hashSetOf(), allowMetaAnnotations: Boolean = true ): Boolean { - val annotationType = annotationClass ?: return false - val annotationFqName = annotationType.fqNameSafe.asString() + val annotationFqName = fqName?.asString() ?: return false if (annotationFqName in visitedAnnotations) return false // Prevent infinite recursion if (annotationFqName in getAnnotationFqNames(modifierListOwner)) return true visitedAnnotations.add(annotationFqName) if (allowMetaAnnotations) { + val annotationType = annotationClass ?: return false for (metaAnnotation in annotationType.annotations) { if (metaAnnotation.isASpecialAnnotation(modifierListOwner, visitedAnnotations, allowMetaAnnotations = true)) { return true @@ -64,4 +63,4 @@ interface AnnotationBasedExtension { return false } -} \ No newline at end of file +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DslScopeViolationCallChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DslScopeViolationCallChecker.kt index ca19cb0190f..e3e7d568714 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DslScopeViolationCallChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DslScopeViolationCallChecker.kt @@ -25,7 +25,6 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.getImplicitReceivers import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperClassifiers import org.jetbrains.kotlin.resolve.scopes.LexicalScope import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue @@ -81,7 +80,7 @@ object DslScopeViolationCallChecker : CallChecker { } private fun Annotations.extractDslMarkerFqNames() = - filter(AnnotationDescriptor::isDslMarker).map { it.annotationClass!!.fqNameSafe } + filter(AnnotationDescriptor::isDslMarker).map { it.fqName!! } private fun AnnotationDescriptor.isDslMarker(): Boolean { val classDescriptor = annotationClass ?: return false diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrFile.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrFile.kt index 370aa0e8c27..adb17eb60f0 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrFile.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrFile.kt @@ -18,15 +18,12 @@ package org.jetbrains.kotlin.ir.declarations import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor -import org.jetbrains.kotlin.descriptors.annotations.checkAnnotationName import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.SourceManager import org.jetbrains.kotlin.ir.symbols.IrExternalPackageFragmentSymbol import org.jetbrains.kotlin.ir.symbols.IrFileSymbol import org.jetbrains.kotlin.ir.symbols.IrPackageFragmentSymbol -import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.visitors.IrElementTransformer -import org.jetbrains.kotlin.name.FqName interface IrPackageFragment : IrElement, IrDeclarationContainer, IrSymbolOwner { val packageFragmentDescriptor: PackageFragmentDescriptor @@ -48,6 +45,3 @@ interface IrFile : IrPackageFragment { } val IrFile.name: String get() = fileEntry.name - -fun IrFile.findAnnotationsByFqName(fqName: FqName) = - fileAnnotations.filter { checkAnnotationName(it, fqName) } \ No newline at end of file diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierList.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierList.kt index 5a63e35211d..af55be7eb15 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierList.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierList.kt @@ -31,8 +31,6 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.AnnotationChecker -import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe import org.jetbrains.kotlin.resolve.source.getPsi abstract class KtLightModifierList>(protected val owner: T) @@ -101,7 +99,7 @@ private fun lightAnnotationsForEntries(lightModifierList: KtLightModifierList<*> return getAnnotationDescriptors(annotatedKtDeclaration, lightModifierListOwner) .mapNotNull { descriptor -> - val fqName = descriptor.annotationClass?.fqNameUnsafe?.asString() ?: return@mapNotNull null + val fqName = descriptor.fqName?.asString() ?: return@mapNotNull null val entry = descriptor.source.getPsi() as? KtAnnotationEntry ?: return@mapNotNull null Pair(fqName, entry) } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt index 8d6833acec6..5277dc53466 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt @@ -45,13 +45,12 @@ class LazyJavaAnnotationDescriptor( private val c: LazyJavaResolverContext, private val javaAnnotation: JavaAnnotation ) : AnnotationDescriptor { - - private val fqName = c.storageManager.createNullableLazyValue { + override val fqName by c.storageManager.createNullableLazyValue { javaAnnotation.classId?.asSingleFqName() } override val type by c.storageManager.createLazyValue { - val fqName = fqName() ?: return@createLazyValue ErrorUtils.createErrorType("No fqName: $javaAnnotation") + val fqName = fqName ?: return@createLazyValue ErrorUtils.createErrorType("No fqName: $javaAnnotation") val annotationClass = JavaToKotlinClassMap.mapJavaToKotlin(fqName, c.module.builtIns) ?: javaAnnotation.resolve()?.let { javaClass -> c.components.moduleClassResolver.resolveClass(javaClass) } ?: createTypeForMissingDependencies(fqName) diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt index 64be02f2ed3..b89d1021bb4 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt @@ -34,8 +34,6 @@ import org.jetbrains.kotlin.load.kotlin.SignatureBuildingComponents import org.jetbrains.kotlin.load.kotlin.computeJvmDescriptor import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.platform.JavaToKotlinClassMap -import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.asFlexibleType import org.jetbrains.kotlin.types.checker.KotlinTypeChecker @@ -48,7 +46,7 @@ import java.util.* class SignatureEnhancement(private val annotationTypeQualifierResolver: AnnotationTypeQualifierResolver) { fun extractNullability(annotationDescriptor: AnnotationDescriptor): NullabilityQualifier? { - val annotationFqName = annotationDescriptor.annotationClass?.fqNameSafe ?: return null + val annotationFqName = annotationDescriptor.fqName ?: return null when (annotationFqName) { in NULLABLE_ANNOTATIONS -> return NullabilityQualifier.NULLABLE in NOT_NULL_ANNOTATIONS -> return NullabilityQualifier.NOT_NULL @@ -58,7 +56,7 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati when { annotationFqName == JAVAX_NONNULL_ANNOTATION -> annotationDescriptor else -> annotationTypeQualifierResolver.resolveTypeQualifierAnnotation(annotationDescriptor) - ?.takeIf { it.annotationClass?.fqNameSafe == JAVAX_NONNULL_ANNOTATION } + ?.takeIf { it.fqName == JAVAX_NONNULL_ANNOTATION } } ?: return null val enumEntryDescriptor = diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.kt index 7635195b5fe..96677ca6a91 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.kt @@ -16,14 +16,21 @@ package org.jetbrains.kotlin.descriptors.annotations +import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.FqNameUnsafe import org.jetbrains.kotlin.resolve.constants.ConstantValue +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe import org.jetbrains.kotlin.types.KotlinType interface AnnotationDescriptor { val type: KotlinType + val fqName: FqName? get() = + (type.constructor.declarationDescriptor as? ClassDescriptor)?.fqNameUnsafe?.takeIf(FqNameUnsafe::isSafe)?.toSafe() + val allValueArguments: Map> val source: SourceElement diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java index 16388ceff22..5e5a339bf27 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java @@ -17,8 +17,10 @@ package org.jetbrains.kotlin.descriptors.annotations; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.descriptors.SourceElement; import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor; +import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.renderer.DescriptorRenderer; import org.jetbrains.kotlin.resolve.constants.ConstantValue; import org.jetbrains.kotlin.types.KotlinType; @@ -47,6 +49,12 @@ public class AnnotationDescriptorImpl implements AnnotationDescriptor { return annotationType; } + @Nullable + @Override + public FqName getFqName() { + return AnnotationDescriptor.DefaultImpls.getFqName(this); + } + @Override @NotNull public Map> getAllValueArguments() { diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt index 28076e92c7d..896e8288748 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt @@ -17,8 +17,6 @@ package org.jetbrains.kotlin.descriptors.annotations import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe interface Annotated { val annotations: Annotations @@ -55,28 +53,21 @@ interface Annotations : Iterable { } fun findAnyAnnotation(annotations: Annotations, fqName: FqName): AnnotationWithTarget? { - return annotations.getAllAnnotations().firstOrNull { checkAnnotationName(it.annotation, fqName) } + return annotations.getAllAnnotations().firstOrNull { it.annotation.fqName == fqName } } fun findUseSiteTargetedAnnotation(annotations: Annotations, target: AnnotationUseSiteTarget, fqName: FqName): AnnotationDescriptor? { - return getUseSiteTargetedAnnotations(annotations, target).firstOrNull { checkAnnotationName(it, fqName) } + return getUseSiteTargetedAnnotations(annotations, target).firstOrNull { it.fqName == fqName } } private fun getUseSiteTargetedAnnotations(annotations: Annotations, target: AnnotationUseSiteTarget): List { - return annotations.getUseSiteTargetedAnnotations().fold(arrayListOf()) { list, targeted -> - if (target == targeted.target) { - list.add(targeted.annotation) - } - list + return annotations.getUseSiteTargetedAnnotations().mapNotNull { (annotation, annotationTarget) -> + annotation.takeIf { target == annotationTarget } } } } } -fun checkAnnotationName(annotation: AnnotationDescriptor, fqName: FqName): Boolean { - return annotation.annotationClass?.fqNameUnsafe == fqName.toUnsafe() -} - class FilteredAnnotations( private val delegate: Annotations, private val fqNameFilter: (FqName) -> Boolean @@ -107,8 +98,8 @@ class FilteredAnnotations( override fun isEmpty() = delegate.any(this::shouldBeReturned) private fun shouldBeReturned(annotation: AnnotationDescriptor): Boolean = - annotation.annotationClass?.fqNameUnsafe.let { fqName -> - fqName != null && fqName.isSafe && fqNameFilter(fqName.toSafe()) + annotation.fqName.let { fqName -> + fqName != null && fqNameFilter(fqName) } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationsImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationsImpl.kt index 58d3630c19c..51ea0d07e11 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationsImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationsImpl.kt @@ -17,8 +17,6 @@ package org.jetbrains.kotlin.descriptors.annotations import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass class AnnotationsImpl : Annotations { private val annotations: List @@ -40,10 +38,7 @@ class AnnotationsImpl : Annotations { override fun isEmpty() = targetedAnnotations.isEmpty() - override fun findAnnotation(fqName: FqName) = annotations.firstOrNull { - val descriptor = it.annotationClass - descriptor != null && fqName.toUnsafe() == DescriptorUtils.getFqName(descriptor) - } + override fun findAnnotation(fqName: FqName) = annotations.firstOrNull { it.fqName == fqName } override fun getUseSiteTargetedAnnotations(): List { return targetedAnnotations diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt index af57479c9c3..57b64f69ca7 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt @@ -31,7 +31,6 @@ import org.jetbrains.kotlin.resolve.constants.AnnotationValue import org.jetbrains.kotlin.resolve.constants.ArrayValue import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.constants.KClassValue -import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.ErrorUtils.UninferredParameterTypeConstructor @@ -398,15 +397,8 @@ internal class DescriptorRendererImpl( val excluded = if (annotated is KotlinType) excludedTypeAnnotationClasses else excludedAnnotationClasses - // Sort is needed just to fix some order when annotations resolved from modifiers - // See AnnotationResolver.resolveAndAppendAnnotationsFromModifiers for clarification - // This hack can be removed when modifiers will be resolved without annotations - - val sortedAnnotations = annotated.annotations.getAllAnnotations() - for ((annotation, target) in sortedAnnotations) { - val annotationClass = annotation.annotationClass!! - - if (!excluded.contains(DescriptorUtils.getFqNameSafe(annotationClass))) { + for ((annotation, target) in annotated.annotations.getAllAnnotations()) { + if (annotation.fqName !in excluded) { append(renderAnnotation(annotation, target)).append(" ") } } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedAnnotations.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedAnnotations.kt index f9f59cb9458..2a1b68816ad 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedAnnotations.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedAnnotations.kt @@ -20,8 +20,6 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.storage.getValue @@ -33,8 +31,7 @@ open class DeserializedAnnotations( override fun isEmpty(): Boolean = annotations.isEmpty() - override fun findAnnotation(fqName: FqName) = - annotations.firstOrNull { annotation -> annotation.annotationClass?.fqNameUnsafe == fqName.toUnsafe() } + override fun findAnnotation(fqName: FqName) = annotations.firstOrNull { it.fqName == fqName } override fun getUseSiteTargetedAnnotations(): List = emptyList() @@ -59,9 +56,7 @@ open class DeserializedAnnotationsWithPossibleTargets( override fun isEmpty(): Boolean = annotations.isEmpty() override fun findAnnotation(fqName: FqName): AnnotationDescriptor? = - annotations.firstOrNull { (annotation, target) -> - target == null && annotation.annotationClass?.fqNameUnsafe == fqName.toUnsafe() - }?.annotation + annotations.firstOrNull { (annotation, target) -> target == null && annotation.fqName == fqName }?.annotation override fun getUseSiteTargetedAnnotations(): List = annotations.filter { it.target != null } diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt index b5cc48e27a5..3bbec3036e3 100644 --- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt +++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt @@ -49,7 +49,6 @@ import org.jetbrains.kotlin.asJava.toLightClass import org.jetbrains.kotlin.asJava.toLightMethods import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotated -import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny import org.jetbrains.kotlin.idea.core.isInheritable @@ -69,9 +68,6 @@ import org.jetbrains.kotlin.idea.util.ProjectRootsUtil import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.* -import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.isError import org.jetbrains.kotlin.util.findCallableMemberBySignature import java.awt.GridBagConstraints import java.awt.GridBagLayout @@ -118,19 +114,14 @@ class UnusedSymbolInspection : AbstractKotlinInspection() { // variation of IDEA's AnnotationUtil.checkAnnotatedUsingPatterns() private fun checkAnnotatedUsingPatterns(annotated: Annotated, annotationPatterns: Collection): Boolean { - val annotationsPresent = annotated.annotations - .map(AnnotationDescriptor::type) - .filterNot(KotlinType::isError) - .mapNotNull { it.constructor.declarationDescriptor?.let { descriptor -> - DescriptorUtils.getFqName(descriptor).asString() - } } - + val annotationsPresent = annotated.annotations.mapNotNull { it.fqName?.asString() } if (annotationsPresent.isEmpty()) return false for (pattern in annotationPatterns) { val hasAnnotation = if (pattern.endsWith(".*")) { annotationsPresent.any { it.startsWith(pattern.dropLast(1)) } - } else { + } + else { pattern in annotationsPresent } if (hasAnnotation) return true @@ -138,7 +129,6 @@ class UnusedSymbolInspection : AbstractKotlinInspection() { return false } - } override fun runForWholeFile() = true diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/migration/MigrateExternalExtensionFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/migration/MigrateExternalExtensionFix.kt index de37af54331..ef0a7ff01e4 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/migration/MigrateExternalExtensionFix.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/migration/MigrateExternalExtensionFix.kt @@ -21,7 +21,6 @@ import com.intellij.openapi.editor.Editor import com.intellij.openapi.project.Project import com.intellij.psi.PsiElement import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.descriptors.annotations.checkAnnotationName import org.jetbrains.kotlin.diagnostics.Diagnostic import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.idea.caches.resolve.analyze @@ -239,7 +238,7 @@ class MigrateExternalExtensionFix(declaration: KtNamedDeclaration) private fun KtAnnotationEntry.isJsAnnotation(vararg predefinedAnnotations: PredefinedAnnotation): Boolean { val bindingContext = analyze(BodyResolveMode.PARTIAL) val annotationDescriptor = bindingContext[BindingContext.ANNOTATION, this] - return annotationDescriptor != null && predefinedAnnotations.any { checkAnnotationName(annotationDescriptor, it.fqName) } + return annotationDescriptor != null && predefinedAnnotations.any { annotationDescriptor.fqName == it.fqName } } private fun KtAnnotationEntry.isJsNativeAnnotation(): Boolean { diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt index 709899fe6f7..8ec81434948 100644 --- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt +++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt @@ -41,8 +41,6 @@ import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.collectDescendantsOfType import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType import org.jetbrains.kotlin.resolve.BindingContext -import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode class KotlinAnnotatedElementsSearcher : QueryExecutor { @@ -102,8 +100,8 @@ class KotlinAnnotatedElementsSearcher : QueryExecutor, actualTargets: List, trace: BindingTrace) { val bindingContext = trace.bindingContext for (entry in entries) { val annotation = bindingContext[BindingContext.ANNOTATION, entry] ?: continue - if (annotation.annotationClass?.fqNameSafe != AnnotationsUtils.JS_QUALIFIER_ANNOTATION) continue + if (annotation.fqName != AnnotationsUtils.JS_QUALIFIER_ANNOTATION) continue val argument = annotation.allValueArguments.values.singleOrNull()?.value as? String ?: continue if (!validateQualifier(argument)) { val argumentPsi = entry.valueArgumentList!!.arguments[0] diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java b/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java index 2f87528afb5..7902c2d144c 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.js.translate.utils; import com.intellij.psi.PsiFile; +import kotlin.collections.CollectionsKt; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.descriptors.*; @@ -25,7 +26,6 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget; import org.jetbrains.kotlin.descriptors.annotations.Annotations; import org.jetbrains.kotlin.js.PredefinedAnnotation; import org.jetbrains.kotlin.name.FqName; -import org.jetbrains.kotlin.name.FqNameUnsafe; import org.jetbrains.kotlin.psi.KtAnnotationEntry; import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.resolve.BindingContext; @@ -38,7 +38,6 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; -import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getAnnotationClass; import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.isEffectivelyExternal; public final class AnnotationsUtils { @@ -221,11 +220,7 @@ public final class AnnotationsUtils { @NotNull FqName annotationFqName ) { for (AnnotationDescriptor annotation : getContainingFileAnnotations(bindingContext, declaration)) { - DeclarationDescriptor annotationType = getAnnotationClass(annotation); - if (annotationType == null) continue; - - FqNameUnsafe fqName = DescriptorUtils.getFqName(annotationType); - if (fqName.equals(annotationFqName.toUnsafe())) { + if (annotationFqName.equals(annotation.getFqName())) { return extractSingleStringArgument(annotation); } } @@ -237,20 +232,9 @@ public final class AnnotationsUtils { } public static boolean isFromNonModuleFile(@NotNull BindingContext bindingContext, @NotNull DeclarationDescriptor declaration) { - for (AnnotationDescriptor annotation : getContainingFileAnnotations(bindingContext, declaration)) { - DeclarationDescriptor annotationType = getAnnotationClass(annotation); - if (annotationType == null) continue; - - DeclarationDescriptor annotationTypeDescriptor = getAnnotationClass(annotation); - assert annotationTypeDescriptor != null : "Annotation type should have descriptor: " + annotation.getType(); - - FqNameUnsafe fqName = DescriptorUtils.getFqName(annotationTypeDescriptor); - if (fqName.equals(JS_NON_MODULE_ANNOTATION.toUnsafe())) { - return true; - } - } - - return false; + return CollectionsKt.any(getContainingFileAnnotations(bindingContext, declaration), annotation -> + JS_NON_MODULE_ANNOTATION.equals(annotation.getFqName()) + ); } @Nullable diff --git a/plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/declarations/KotlinUAnnotation.kt b/plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/declarations/KotlinUAnnotation.kt index 14bab26b0b1..55a8f9009f3 100644 --- a/plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/declarations/KotlinUAnnotation.kt +++ b/plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/declarations/KotlinUAnnotation.kt @@ -5,7 +5,6 @@ import com.intellij.psi.PsiElement import org.jetbrains.kotlin.psi.KtAnnotationEntry import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.uast.* class KotlinUAnnotation( @@ -15,7 +14,7 @@ class KotlinUAnnotation( private val resolvedAnnotation by lz { psi.analyze()[BindingContext.ANNOTATION, psi] } override val qualifiedName: String? - get() = resolvedAnnotation?.annotationClass?.fqNameSafe?.asString() + get() = resolvedAnnotation?.fqName?.asString() override val attributeValues by lz { val context = getUastContext()