From def3f73fddac2acf566b1c670e438d884326c57e Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Tue, 4 Jul 2017 18:38:36 +0300 Subject: [PATCH] Use AnnotationDescriptor.fqName instead of type Also use the annotationClass extension property instead of TypeUtils.getClassDescriptor(annotation.type) --- .../jvm/checkers/annotationCheckers.kt | 13 ++++++----- .../kotlin/resolve/AnnotationChecker.kt | 6 ++--- .../kotlin/resolve/TypeAliasExpander.kt | 4 ++-- .../checkers/PublishedApiUsageChecker.kt | 11 +++------ .../diagnostics/KotlinSuppressCache.kt | 2 +- .../SuppressDiagnosticsByAnnotations.kt | 20 ++++------------ .../lazy/descriptors/LazyAnnotations.kt | 23 ++++--------------- .../LoadJavaPackageAnnotationsTest.kt | 5 +--- .../kotlin/builtins/KotlinBuiltIns.java | 11 ++++----- .../annotations/AnnotationDescriptor.kt | 8 +++---- .../kotlin/renderer/DescriptorRendererImpl.kt | 3 ++- .../quickfix/KotlinSuppressIntentionAction.kt | 10 +++----- .../idea/util/modifierListModifactor.kt | 15 +----------- .../kotlin/idea/patterns/KotlinPatterns.kt | 7 +++--- .../migration/MigrateExternalExtensionFix.kt | 2 +- .../diagnostics/JsExternalFileChecker.kt | 8 +++---- 16 files changed, 48 insertions(+), 100 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/annotationCheckers.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/annotationCheckers.kt index 329a879ddff..fb54a818704 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/annotationCheckers.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/annotationCheckers.kt @@ -21,28 +21,29 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtAnnotationEntry import org.jetbrains.kotlin.resolve.AdditionalAnnotationChecker import org.jetbrains.kotlin.resolve.AnnotationChecker 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.classId import org.jetbrains.kotlin.resolve.descriptorUtil.getAnnotationRetention import org.jetbrains.kotlin.resolve.descriptorUtil.isRepeatableAnnotation import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.TypeUtils object RepeatableAnnotationChecker: AdditionalAnnotationChecker { override fun checkEntries(entries: List, actualTargets: List, trace: BindingTrace) { - val entryTypesWithAnnotations = hashMapOf>() + val entryTypesWithAnnotations = hashMapOf>() for (entry in entries) { val descriptor = trace.get(BindingContext.ANNOTATION, entry) ?: continue - val classDescriptor = TypeUtils.getClassDescriptor(descriptor.type) ?: continue + val fqName = descriptor.fqName ?: continue + val classDescriptor = descriptor.annotationClass ?: continue val useSiteTarget = entry.useSiteTarget?.getAnnotationUseSiteTarget() - val existingTargetsForAnnotation = entryTypesWithAnnotations.getOrPut(descriptor.type) { arrayListOf() } + val existingTargetsForAnnotation = entryTypesWithAnnotations.getOrPut(fqName) { arrayListOf() } val duplicateAnnotation = useSiteTarget in existingTargetsForAnnotation || (existingTargetsForAnnotation.any { (it == null) != (useSiteTarget == null) }) @@ -66,7 +67,7 @@ object FileClassAnnotationsChecker: AdditionalAnnotationChecker { for (entry in entries) { if (entry.useSiteTarget?.getAnnotationUseSiteTarget() != AnnotationUseSiteTarget.FILE) continue val descriptor = trace.get(BindingContext.ANNOTATION, entry) ?: continue - val classDescriptor = TypeUtils.getClassDescriptor(descriptor.type) ?: continue + val classDescriptor = descriptor.annotationClass ?: continue // This check matters for the applicable annotations only. val applicableTargets = AnnotationChecker.applicableTargetSet(classDescriptor) if (applicableTargets == null || !applicableTargets.contains(KotlinTarget.FILE)) continue diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt index a71c45336d3..1d01f0bc300 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt @@ -35,7 +35,6 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.getAnnotationRetention import org.jetbrains.kotlin.resolve.descriptorUtil.isRepeatableAnnotation import org.jetbrains.kotlin.resolve.inline.InlineUtil import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils import org.jetbrains.kotlin.types.isError @@ -107,7 +106,7 @@ class AnnotationChecker(private val additionalCheckers: Iterable { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeAliasExpander.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeAliasExpander.kt index d4246b286d2..8a932bb1297 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeAliasExpander.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeAliasExpander.kt @@ -142,10 +142,10 @@ class TypeAliasExpander( } private fun checkRepeatedAnnotations(existingAnnotations: Annotations, newAnnotations: Annotations) { - val existingAnnotationTypes = existingAnnotations.mapTo(hashSetOf()) { it.type } + val existingAnnotationFqNames = existingAnnotations.mapTo(hashSetOf()) { it.fqName } for (annotation in newAnnotations) { - if (annotation.type in existingAnnotationTypes) { + if (annotation.fqName in existingAnnotationFqNames) { reportStrategy.repeatedAnnotation(annotation) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/PublishedApiUsageChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/PublishedApiUsageChecker.kt index 7e05efb44f3..0dad7682089 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/PublishedApiUsageChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/PublishedApiUsageChecker.kt @@ -25,27 +25,22 @@ import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.BindingTrace -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe -import org.jetbrains.kotlin.types.TypeUtils object PublishedApiUsageChecker { - fun check( declaration: KtDeclaration, descriptor: DeclarationDescriptor, trace: BindingTrace ) { if (descriptor !is DeclarationDescriptorWithVisibility || descriptor.visibility == Visibilities.INTERNAL) return - /*Don't report diagnostic twise*/ + // Don't report the diagnostic twice if (descriptor is PropertyAccessorDescriptor) return for (entry in declaration.annotationEntries) { val annotationDescriptor = trace.get(BindingContext.ANNOTATION, entry) ?: continue - val classDescriptor = TypeUtils.getClassDescriptor(annotationDescriptor.type) ?: continue - if (classDescriptor.fqNameSafe == KotlinBuiltIns.FQ_NAMES.publishedApi) { + if (annotationDescriptor.fqName == KotlinBuiltIns.FQ_NAMES.publishedApi) { trace.report(Errors.NON_INTERNAL_PUBLISHED_API.on(entry)) } } } -} \ No newline at end of file +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/KotlinSuppressCache.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/KotlinSuppressCache.kt index b7e7348d48c..e734d9d9cc9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/KotlinSuppressCache.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/KotlinSuppressCache.kt @@ -171,7 +171,7 @@ abstract class KotlinSuppressCache { builder.addAll(suppressStringProvider[annotationDescriptor]) } - if (!KotlinBuiltIns.isSuppressAnnotation(annotationDescriptor)) return + if (annotationDescriptor.fqName != KotlinBuiltIns.FQ_NAMES.suppress) return // We only add strings and skip other values to facilitate recovery in presence of erroneous code for (arrayValue in annotationDescriptor.allValueArguments.values) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/SuppressDiagnosticsByAnnotations.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/SuppressDiagnosticsByAnnotations.kt index 17312d0cf01..7f43c9e513d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/SuppressDiagnosticsByAnnotations.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/SuppressDiagnosticsByAnnotations.kt @@ -16,17 +16,12 @@ package org.jetbrains.kotlin.resolve.diagnostics +import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor -import org.jetbrains.kotlin.diagnostics.Errors -import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.diagnostics.Diagnostic -import org.jetbrains.kotlin.diagnostics.DiagnosticFactory +import org.jetbrains.kotlin.diagnostics.* import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtFunction -import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor -import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1 import org.jetbrains.kotlin.psi.KtProperty -import org.jetbrains.kotlin.diagnostics.DiagnosticFactory0 val FUNCTION_NO_BODY_ERRORS: List> = listOf(Errors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY, Errors.NON_MEMBER_FUNCTION_NO_BODY) @@ -36,18 +31,13 @@ val PROPERTY_NOT_INITIALIZED_ERRORS: List> = abstract class SuppressDiagnosticsByAnnotations( diagnosticsToSuppress: List>, - vararg annotationsFqName: FqName + vararg annotationFqNames: FqName ) : SuppressStringProvider { private val stringsToSuppress = diagnosticsToSuppress.map { it.name.toLowerCase() } - private val expectedFqNames = annotationsFqName.map(FqName::toString) + private val expectedFqNames = annotationFqNames.toSet() override fun get(annotationDescriptor: AnnotationDescriptor): List { - val descriptor = DescriptorUtils.getClassDescriptorForType(annotationDescriptor.type) - val actualFqName = DescriptorUtils.getFqName(descriptor).asString() - - if (expectedFqNames.any { it == actualFqName }) return stringsToSuppress - - return listOf() + return if (annotationDescriptor.fqName in expectedFqNames) stringsToSuppress else emptyList() } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt index 626c9a4fec3..f8d13f7b9a0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt @@ -23,7 +23,10 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.KtAnnotationEntry -import org.jetbrains.kotlin.resolve.* +import org.jetbrains.kotlin.resolve.AnnotationResolver +import org.jetbrains.kotlin.resolve.AnnotationResolverImpl +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil import org.jetbrains.kotlin.resolve.lazy.LazyEntity @@ -31,7 +34,6 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScope import org.jetbrains.kotlin.resolve.source.toSourceElement import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.storage.getValue -import org.jetbrains.kotlin.types.isError abstract class LazyAnnotationsContext( val annotationResolver: AnnotationResolver, @@ -62,22 +64,7 @@ class LazyAnnotations( AnnotationWithTarget(descriptor, target) } - override fun findAnnotation(fqName: FqName): AnnotationDescriptor? { - // We can not efficiently check short names here: - // an annotation class may be renamed on import - for (annotationDescriptor in iterator()) { - val annotationType = annotationDescriptor.type - if (annotationType.isError) continue - - val descriptor = annotationType.constructor.declarationDescriptor ?: continue - - if (DescriptorUtils.getFqNameSafe(descriptor) == fqName) { - return annotationDescriptor - } - } - - return null - } + override fun findAnnotation(fqName: FqName): AnnotationDescriptor? = firstOrNull { it.fqName == fqName } override fun getUseSiteTargetedAnnotations(): List { return annotationEntries diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt index efa095a8bec..53086a5836b 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt @@ -25,7 +25,6 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaPackageFragment import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils @@ -75,9 +74,7 @@ class LoadJavaPackageAnnotationsTest : KtUsefulTestCase() { val singleAnnotation = packageFragmentDescriptor.annotations.singleOrNull() assertNotNull(singleAnnotation) - val annotationFqName = singleAnnotation!!.type.constructor.declarationDescriptor?.fqNameSafe - - assertEquals(FqName("test.Ann"), annotationFqName) + assertEquals(FqName("test.Ann"), singleAnnotation!!.fqName) } fun testAnnotationFromSource() { diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java index 5196af914c2..e3b468dc903 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java @@ -24,7 +24,10 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.functions.BuiltInFictitiousFunctionClassFactory; import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor; import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.descriptors.annotations.*; +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget; +import org.jetbrains.kotlin.descriptors.annotations.Annotations; +import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention; +import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget; import org.jetbrains.kotlin.descriptors.deserialization.AdditionalClassPartsProvider; import org.jetbrains.kotlin.descriptors.deserialization.ClassDescriptorFactory; import org.jetbrains.kotlin.descriptors.deserialization.PlatformDependentDeclarationFilter; @@ -254,7 +257,7 @@ public abstract class KotlinBuiltIns { public final FqNameUnsafe any = fqNameUnsafe("Any"); public final FqNameUnsafe nothing = fqNameUnsafe("Nothing"); public final FqNameUnsafe cloneable = fqNameUnsafe("Cloneable"); - public final FqNameUnsafe suppress = fqNameUnsafe("Suppress"); + public final FqName suppress = fqName("Suppress"); public final FqNameUnsafe unit = fqNameUnsafe("Unit"); public final FqNameUnsafe charSequence = fqNameUnsafe("CharSequence"); public final FqNameUnsafe string = fqNameUnsafe("String"); @@ -1095,10 +1098,6 @@ public abstract class KotlinBuiltIns { return BUILT_INS_PACKAGE_FQ_NAME.child(primitiveType.getTypeName()); } - public static boolean isSuppressAnnotation(@NotNull AnnotationDescriptor annotationDescriptor) { - return isConstructedFromGivenClass(annotationDescriptor.getType(), FQ_NAMES.suppress); - } - private static boolean containsAnnotation(DeclarationDescriptor descriptor, FqName annotationClassFqName) { DeclarationDescriptor original = descriptor.getOriginal(); Annotations annotations = original.getAnnotations(); 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 4a82fd7a69a..bab0babc6f3 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.kt @@ -16,21 +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.name.Name import org.jetbrains.kotlin.resolve.constants.ConstantValue +import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe +import org.jetbrains.kotlin.types.ErrorUtils 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 fqName: FqName? + get() = annotationClass?.takeUnless(ErrorUtils::isError)?.fqNameUnsafe?.takeIf(FqNameUnsafe::isSafe)?.toSafe() val allValueArguments: Map> diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt index f61e79791f0..84f3725faaf 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt @@ -31,6 +31,7 @@ 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 @@ -428,7 +429,7 @@ internal class DescriptorRendererImpl( private fun renderAndSortAnnotationArguments(descriptor: AnnotationDescriptor): List { val allValueArguments = descriptor.allValueArguments - val classDescriptor = if (renderDefaultAnnotationArguments) TypeUtils.getClassDescriptor(descriptor.type) else null + val classDescriptor = if (renderDefaultAnnotationArguments) descriptor.annotationClass else null val parameterDescriptorsWithDefaultValue = classDescriptor?.unsubstitutedPrimaryConstructor?.valueParameters ?.filter { it.declaresDefaultValue() } ?.map { it.name } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/KotlinSuppressIntentionAction.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/KotlinSuppressIntentionAction.kt index c9a525b30eb..8d63747f229 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/KotlinSuppressIntentionAction.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/KotlinSuppressIntentionAction.kt @@ -53,7 +53,7 @@ class KotlinSuppressIntentionAction private constructor( val id = "\"$suppressKey\"" when (suppressAt) { is KtModifierListOwner -> - suppressAt.addAnnotation(KotlinBuiltIns.FQ_NAMES.suppress.toSafe(), + suppressAt.addAnnotation(KotlinBuiltIns.FQ_NAMES.suppress, id, whiteSpaceText = if (kind.newLineNeeded) "\n" else " ", addToExistingAnnotation = { entry -> @@ -151,13 +151,9 @@ class KotlinSuppressIntentionAction private constructor( } private fun findSuppressAnnotation(context: BindingContext, annotationEntries: List): KtAnnotationEntry? { - for (entry in annotationEntries) { - val annotationDescriptor = context.get(BindingContext.ANNOTATION, entry) - if (annotationDescriptor != null && KotlinBuiltIns.isSuppressAnnotation(annotationDescriptor)) { - return entry - } + return annotationEntries.firstOrNull { entry -> + context.get(BindingContext.ANNOTATION, entry)?.fqName == KotlinBuiltIns.FQ_NAMES.suppress } - return null } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/modifierListModifactor.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/modifierListModifactor.kt index 5463eb307d6..93ee365802c 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/modifierListModifactor.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/modifierListModifactor.kt @@ -18,13 +18,11 @@ package org.jetbrains.kotlin.idea.util import org.jetbrains.kotlin.idea.caches.resolve.analyze import org.jetbrains.kotlin.idea.core.ShortenReferences -import org.jetbrains.kotlin.js.descriptorUtils.getJetTypeFqName import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode - fun KtModifierListOwner.addAnnotation( annotationFqName: FqName, annotationInnerText: String? = null, @@ -75,16 +73,5 @@ fun KtAnnotated.findAnnotation(annotationFqName: FqName): KtAnnotationEntry? { val context = analyze(bodyResolveMode = BodyResolveMode.PARTIAL) - for (entry in annotationEntries) { - val annotationDescriptor = context.get(BindingContext.ANNOTATION, entry) - if (annotationDescriptor != null) { - val fqName = annotationDescriptor.type.getJetTypeFqName(false) - if (fqName == annotationFqName.asString()) { - return entry - } - } - } - - return null + return annotationEntries.firstOrNull { entry -> context.get(BindingContext.ANNOTATION, entry)?.fqName == annotationFqName } } - diff --git a/idea/src/org/jetbrains/kotlin/idea/patterns/KotlinPatterns.kt b/idea/src/org/jetbrains/kotlin/idea/patterns/KotlinPatterns.kt index a070ad50d86..72a60dd4b7c 100644 --- a/idea/src/org/jetbrains/kotlin/idea/patterns/KotlinPatterns.kt +++ b/idea/src/org/jetbrains/kotlin/idea/patterns/KotlinPatterns.kt @@ -118,10 +118,9 @@ class KtParameterPattern : PsiElementPattern(Kt return withPatternCondition("KtParameterPattern-withAnnotation") { ktParameter, _ -> if (ktParameter.annotationEntries.isEmpty()) return@withPatternCondition false - val parameterDescriptor = ktParameter.resolveToDescriptorIfAny() as? ValueParameterDescriptor ?: return@withPatternCondition false - - parameterDescriptor.annotations.any { annotation -> - DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(annotation.type) == fqName + val parameterDescriptor = ktParameter.resolveToDescriptorIfAny() + parameterDescriptor is ValueParameterDescriptor && parameterDescriptor.annotations.any { annotation -> + annotation.fqName?.asString() == fqName } } } 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 ef0a7ff01e4..27408cc7c87 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/migration/MigrateExternalExtensionFix.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/migration/MigrateExternalExtensionFix.kt @@ -204,7 +204,7 @@ class MigrateExternalExtensionFix(declaration: KtNamedDeclaration) } if (declaration is KtFunction) { - declaration.addAnnotation(KotlinBuiltIns.FQ_NAMES.suppress.toSafe(), "\"NOTHING_TO_INLINE\"") + declaration.addAnnotation(KotlinBuiltIns.FQ_NAMES.suppress, "\"NOTHING_TO_INLINE\"") } convertNativeAnnotationToJsName(declaration, annotations) diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsExternalFileChecker.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsExternalFileChecker.kt index 17cce6f6e67..5801a97b4f2 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsExternalFileChecker.kt +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsExternalFileChecker.kt @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.checkers.SimpleDeclarationChecker -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe object JsExternalFileChecker : SimpleDeclarationChecker { private val annotationFqNames = setOf(AnnotationsUtils.JS_MODULE_ANNOTATION, AnnotationsUtils.JS_QUALIFIER_ANNOTATION) @@ -36,11 +35,10 @@ object JsExternalFileChecker : SimpleDeclarationChecker { ) { if (!AnnotationsUtils.isNativeObject(descriptor) && DescriptorUtils.isTopLevelDeclaration(descriptor)) { AnnotationsUtils.getContainingFileAnnotations(bindingContext, descriptor).asSequence() - .map { it.type } - .firstOrNull { it.constructor.declarationDescriptor?.fqNameSafe in annotationFqNames } + .firstOrNull { it.fqName in annotationFqNames } ?.let { - diagnosticHolder.report(ErrorsJs.NON_EXTERNAL_DECLARATION_IN_INAPPROPRIATE_FILE.on(declaration, it)) + diagnosticHolder.report(ErrorsJs.NON_EXTERNAL_DECLARATION_IN_INAPPROPRIATE_FILE.on(declaration, it.type)) } } } -} \ No newline at end of file +}