Drop Annotations.findAnyAnnotation, DescriptorUtils.getAnnotationByFqName

compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java

@@ -56,12 +56,8 @@ public abstract class AnnotationCodegen {
             this.jvmFlag = jvmFlag;
         }
 
-        public boolean hasAnnotation(@NotNull Annotated annotated) {
+        public int getJvmFlag(@Nullable Annotated annotated) {
-            return Annotations.Companion.findAnyAnnotation(annotated.getAnnotations(), fqName) != null;
+            return annotated != null && annotated.getAnnotations().hasAnnotation(fqName) ? jvmFlag : 0;
-        }
-
-        public int getJvmFlag() {
-            return jvmFlag;
         }
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java

@@ -225,9 +225,7 @@ public class AsmUtil {
         int flags = getCommonCallableFlags(functionDescriptor, state);
 
         for (AnnotationCodegen.JvmFlagAnnotation flagAnnotation : AnnotationCodegen.METHOD_FLAGS) {
-            if (flagAnnotation.hasAnnotation(functionDescriptor.getOriginal())) {
+            flags |= flagAnnotation.getJvmFlag(functionDescriptor.getOriginal());
-                flags |= flagAnnotation.getJvmFlag();
-            }
         }
 
         if (functionDescriptor.getOriginal().isExternal()) {

compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java

@@ -370,9 +370,7 @@ public class PropertyCodegen {
         int modifiers = getDeprecatedAccessFlag(propertyDescriptor);
 
         for (AnnotationCodegen.JvmFlagAnnotation flagAnnotation : AnnotationCodegen.FIELD_FLAGS) {
-            if (annotatedField != null && flagAnnotation.hasAnnotation(annotatedField)) {
+            modifiers |= flagAnnotation.getJvmFlag(annotatedField);
-                modifiers |= flagAnnotation.getJvmFlag();
-            }
         }
 
         if (kind == OwnerKind.PACKAGE) {

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/annotations/jvmAnnotationUtil.kt

@@ -43,14 +43,14 @@ fun CallableMemberDescriptor.hasJvmDefaultAnnotation(): Boolean =
     DescriptorUtils.getDirectMember(this).annotations.hasAnnotation(JVM_DEFAULT_FQ_NAME)
 
 private fun Annotated.findJvmSyntheticAnnotation(): AnnotationDescriptor? =
-    DescriptorUtils.getAnnotationByFqName(annotations, JVM_SYNTHETIC_ANNOTATION_FQ_NAME)
+    annotations.findAnnotation(JVM_SYNTHETIC_ANNOTATION_FQ_NAME)
         ?: (this as? PropertyDescriptor)?.backingField?.annotations?.findAnnotation(JVM_SYNTHETIC_ANNOTATION_FQ_NAME)
 
 fun DeclarationDescriptor.hasJvmSyntheticAnnotation(): Boolean =
     findJvmSyntheticAnnotation() != null
 
 fun DeclarationDescriptor.findStrictfpAnnotation(): AnnotationDescriptor? =
-    DescriptorUtils.getAnnotationByFqName(annotations, STRICTFP_ANNOTATION_FQ_NAME)
+    annotations.findAnnotation(STRICTFP_ANNOTATION_FQ_NAME)
 
 fun DeclarationDescriptor.findSynchronizedAnnotation(): AnnotationDescriptor? =
-    DescriptorUtils.getAnnotationByFqName(annotations, SYNCHRONIZED_ANNOTATION_FQ_NAME)
+    annotations.findAnnotation(SYNCHRONIZED_ANNOTATION_FQ_NAME)

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt

@@ -122,9 +122,9 @@ class JvmStaticChecker(jvmTarget: JvmTarget, languageVersionSettings: LanguageVe
 
 class JvmNameAnnotationChecker : DeclarationChecker {
     override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) {
-        val platformNameAnnotation = DescriptorUtils.getJvmNameAnnotation(descriptor)
+        val jvmNameAnnotation = DescriptorUtils.findJvmNameAnnotation(descriptor)
-        if (platformNameAnnotation != null) {
+        if (jvmNameAnnotation != null) {
-            checkDeclaration(descriptor, platformNameAnnotation, context.trace)
+            checkDeclaration(descriptor, jvmNameAnnotation, context.trace)
         }
     }
 

core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt

@@ -58,10 +58,6 @@ interface Annotations : Iterable<AnnotationDescriptor> {
             override fun toString() = "EMPTY"
         }
 
-        fun findAnyAnnotation(annotations: Annotations, fqName: FqName): AnnotationWithTarget? {
-            return annotations.getAllAnnotations().firstOrNull { it.annotation.fqName == fqName }
-        }
-
         fun findUseSiteTargetedAnnotation(annotations: Annotations, target: AnnotationUseSiteTarget, fqName: FqName): AnnotationDescriptor? {
             return getUseSiteTargetedAnnotations(annotations, target).firstOrNull { it.fqName == fqName }
         }

core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java

@@ -12,8 +12,6 @@ import org.jetbrains.kotlin.builtins.UnsignedTypes;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotated;
 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.incremental.components.LookupLocation;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.name.FqName;
@@ -538,7 +536,7 @@ public class DescriptorUtils {
 
     @Nullable
     public static String getJvmName(@NotNull Annotated annotated) {
-        return getJvmName(getJvmNameAnnotation(annotated));
+        return getJvmName(findJvmNameAnnotation(annotated));
     }
 
     @Nullable
@@ -555,14 +553,8 @@ public class DescriptorUtils {
     }
 
     @Nullable
-    public static AnnotationDescriptor getAnnotationByFqName(@NotNull Annotations annotations, @NotNull FqName name) {
+    public static AnnotationDescriptor findJvmNameAnnotation(@NotNull Annotated annotated) {
-        AnnotationWithTarget annotationWithTarget = Annotations.Companion.findAnyAnnotation(annotations, name);
+        return annotated.getAnnotations().findAnnotation(JVM_NAME);
-        return annotationWithTarget == null ? null : annotationWithTarget.getAnnotation();
-    }
-
-    @Nullable
-    public static AnnotationDescriptor getJvmNameAnnotation(@NotNull Annotated annotated) {
-        return getAnnotationByFqName(annotated.getAnnotations(), JVM_NAME);
     }
 
     @NotNull

idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt

@@ -38,7 +38,6 @@ import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.config.AnalysisFlag
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.idea.caches.project.implementingDescriptors
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor
@@ -300,9 +299,7 @@ class UnusedSymbolInspection : AbstractKotlinInspection() {
         )
         val referenceUsed: Boolean by lazy { !ReferencesSearch.search(searchParameters).forEach(::checkReference) }
 
-        if (descriptor is FunctionDescriptor &&
+        if (descriptor is FunctionDescriptor && DescriptorUtils.findJvmNameAnnotation(descriptor) != null) {
-            DescriptorUtils.getAnnotationByFqName(descriptor.annotations, JvmFileClassUtil.JVM_NAME) != null
-        ) {
             if (referenceUsed) return true
         }
 

js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java

@@ -22,8 +22,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 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.js.PredefinedAnnotation;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.KtAnnotationEntry;
@@ -111,13 +109,7 @@ public final class AnnotationsUtils {
             @NotNull DeclarationDescriptor descriptor,
             @NotNull PredefinedAnnotation annotation
     ) {
-        return getAnnotationByName(descriptor, annotation.getFqName());
+        return descriptor.getAnnotations().findAnnotation(annotation.getFqName());
-    }
-
-    @Nullable
-    private static AnnotationDescriptor getAnnotationByName(@NotNull DeclarationDescriptor descriptor, @NotNull FqName fqName) {
-        AnnotationWithTarget annotationWithTarget = Annotations.Companion.findAnyAnnotation(descriptor.getAnnotations(), (fqName));
-        return annotationWithTarget != null ? annotationWithTarget.getAnnotation() : null;
     }
 
     public static boolean isNativeObject(@NotNull DeclarationDescriptor descriptor) {
@@ -159,7 +151,7 @@ public final class AnnotationsUtils {
 
     @Nullable
     public static AnnotationDescriptor getJsNameAnnotation(@NotNull DeclarationDescriptor descriptor) {
-        return getAnnotationByName(descriptor, new FqName(JS_NAME));
+        return descriptor.getAnnotations().findAnnotation(new FqName(JS_NAME));
     }
 
     public static boolean isPredefinedObject(@NotNull DeclarationDescriptor descriptor) {
@@ -183,9 +175,8 @@ public final class AnnotationsUtils {
     }
 
     private static boolean hasAnnotationOrInsideAnnotatedClass(@NotNull DeclarationDescriptor descriptor, @NotNull FqName fqName) {
-        if (getAnnotationByName(descriptor, fqName) != null) {
+        if (descriptor.getAnnotations().hasAnnotation(fqName)) return true;
-            return true;
+
-        }
         ClassDescriptor containingClass = DescriptorUtils.getContainingClass(descriptor);
         return containingClass != null && hasAnnotationOrInsideAnnotatedClass(containingClass, fqName);
     }