Introduce AnnotationDescriptor.fqName

Could be used instead of ".annotationClass.fqName" to avoid the unneeded resolution of the annotation class descriptor
2017-07-04 15:21:52 +03:00
parent 1d64b61a8f
commit 41ea0e8ef8
18 changed files with 48 additions and 105 deletions
@@ -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<String> = 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
    }
-}
+}
@@ -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
@@ -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) }
@@ -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<out T : KtLightElement<KtModifierListOwner, PsiModifierListOwner>>(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)
            }
@@ -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)
@@ -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 =
@@ -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<ValueParameterDescriptor, ConstantValue<*>>

    val source: SourceElement
@@ -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<ValueParameterDescriptor, ConstantValue<?>> getAllValueArguments() {
@@ -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<AnnotationDescriptor> {
        }

        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<AnnotationDescriptor> {
-            return annotations.getUseSiteTargetedAnnotations().fold(arrayListOf<AnnotationDescriptor>()) { 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)
            }
 }

@@ -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<AnnotationDescriptor>
@@ -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<AnnotationWithTarget> {
        return targetedAnnotations
@@ -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(" ")
            }
        }
@@ -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<AnnotationWithTarget> = 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<AnnotationWithTarget> = annotations.filter { it.target != null }

@@ -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<String>): 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
@@ -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 {
@@ -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<PsiModifierListOwner, AnnotatedElementsSearch.Parameters> {
@@ -102,8 +100,8 @@ class KotlinAnnotatedElementsSearcher : QueryExecutor<PsiModifierListOwner, Anno
                        val context = elt.analyze(BodyResolveMode.PARTIAL)
                        val annotationDescriptor = context.get(BindingContext.ANNOTATION, elt) ?: return true

-                        val descriptor = annotationDescriptor.annotationClass ?: return true
-                        if (DescriptorUtils.getFqName(descriptor).asString() != annotationFQN) return true
+                        val fqName = annotationDescriptor.fqName ?: return true
+                        if (fqName.asString() != annotationFQN) return true
                    }

                    if (!consumer(declaration)) return false
@@ -22,15 +22,13 @@ import org.jetbrains.kotlin.psi.KtAnnotationEntry
 import org.jetbrains.kotlin.resolve.AdditionalAnnotationChecker
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe

 object JsQualifierChecker : AdditionalAnnotationChecker {
    override fun checkEntries(entries: List<KtAnnotationEntry>, actualTargets: List<KotlinTarget>, 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]
@@ -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
@@ -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()