Drop Annotations.getAllAnnotations

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

@@ -245,7 +245,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     private void genTypeAliasAnnotationsMethodIfRequired(TypeAliasDescriptor typeAliasDescriptor) {
         boolean isAnnotationsMethodOwner = CodegenContextUtil.isImplClassOwner(context);
         Annotations annotations = typeAliasDescriptor.getAnnotations();
-        if (!isAnnotationsMethodOwner || annotations.getAllAnnotations().isEmpty()) return;
+        if (!isAnnotationsMethodOwner || annotations.isEmpty()) return;
 
         String name = JvmAbi.getSyntheticMethodNameForAnnotatedTypeAlias(typeAliasDescriptor.getName());
         generateSyntheticAnnotationsMethod(typeAliasDescriptor, new Method(name, "()V"), annotations);

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

@@ -335,7 +335,7 @@ public class PropertyCodegen {
     // accessible via reflection, and 'deprecated' and 'synthetic' flags prevent this method from being called accidentally
     private void generateSyntheticMethodIfNeeded(@NotNull PropertyDescriptor descriptor, boolean isBackingFieldOwner) {
         Annotations annotations = descriptor.getAnnotations();
-        if (annotations.getAllAnnotations().isEmpty()) return;
+        if (annotations.isEmpty()) return;
 
         Method signature = getSyntheticMethodSignature(descriptor);
         if (kind != OwnerKind.DEFAULT_IMPLS && CodegenContextUtil.isImplClassOwner(context)) {

compiler/frontend/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationSplitter.kt

@@ -92,14 +92,7 @@ class AnnotationSplitter(
         val applicableTargets = applicableTargetsLazy()
         val applicableTargetsWithoutUseSiteTarget = applicableTargets.intersect(TARGET_PRIORITIES)
 
-        outer@ for ((annotation, useSiteTarget) in allAnnotations.getAllAnnotations()) {
+        outer@ for (annotation in allAnnotations) {
-            if (useSiteTarget != null) {
-                if (useSiteTarget in applicableTargets)
-                    map.getOrPut(useSiteTarget) { arrayListOf() }.add(annotation)
-
-                continue@outer
-            }
-
             for (target in TARGET_PRIORITIES) {
                 if (target !in applicableTargetsWithoutUseSiteTarget) continue
 
@@ -115,6 +108,14 @@ class AnnotationSplitter(
             other.add(annotation)
         }
 
+        for ((annotation, useSiteTarget) in allAnnotations.getUseSiteTargetedAnnotations()) {
+            if (useSiteTarget == null) continue
+
+            if (useSiteTarget in applicableTargets) {
+                map.getOrPut(useSiteTarget) { arrayListOf() }.add(annotation)
+            }
+        }
+
         map to AnnotationsImpl(other)
     }
 
@@ -137,14 +138,15 @@ class AnnotationSplitter(
         }
 
         override fun forceResolveAllContents() {
-            getAllAnnotations()
+            for (annotation in this) {
+                // TODO: probably we should do ForceResolveUtil.forceResolveAllContents(annotation) here
+            }
         }
 
         override fun isEmpty() = annotations.isEmpty()
         override fun hasAnnotation(fqName: FqName) = annotations.hasAnnotation(fqName)
         override fun findAnnotation(fqName: FqName) = annotations.findAnnotation(fqName)
         override fun getUseSiteTargetedAnnotations() = annotations.getUseSiteTargetedAnnotations()
-        override fun getAllAnnotations() = annotations.getAllAnnotations()
         override fun iterator() = annotations.iterator()
         override fun toString() = annotations.toString()
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ForceResolveUtil.java

@@ -20,7 +20,7 @@ import com.intellij.openapi.diagnostic.Logger;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget;
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
@@ -64,8 +64,8 @@ public class ForceResolveUtil {
 
     public static void forceResolveAllContents(@NotNull Annotations annotations) {
         doForceResolveAllContents(annotations);
-        for (AnnotationWithTarget annotationWithTarget : annotations.getAllAnnotations()) {
+        for (AnnotationDescriptor annotation : annotations) {
-            doForceResolveAllContents(annotationWithTarget.getAnnotation());
+            doForceResolveAllContents(annotation);
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt

@@ -56,7 +56,6 @@ class LazyAnnotations(
     override fun isEmpty() = annotationEntries.isEmpty()
 
     private val annotation = c.storageManager.createMemoizedFunction { entry: KtAnnotationEntry ->
-
         val descriptor = LazyAnnotationDescriptor(c, entry)
         val target = entry.useSiteTarget?.getAnnotationUseSiteTarget()
         AnnotationWithTarget(descriptor, target)
@@ -70,8 +69,6 @@ class LazyAnnotations(
             }
     }
 
-    override fun getAllAnnotations() = annotationEntries.map(annotation)
-
     override fun iterator(): Iterator<AnnotationDescriptor> {
         return annotationEntries
             .asSequence()
@@ -83,7 +80,9 @@ class LazyAnnotations(
 
     override fun forceResolveAllContents() {
         // To resolve all entries
-        getAllAnnotations()
+        for (annotation in this) {
+            // TODO: probably we should do ForceResolveUtil.forceResolveAllContents(annotation) here
+        }
     }
 }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt

@@ -109,10 +109,7 @@ class TypeTranslator(
     }
 
     private fun translateTypeAnnotations(annotations: Annotations): List<IrCall> =
-        annotations.getAllAnnotations().map {
+        annotations.map(constantValueGenerator::generateAnnotationConstructorCall)
-            // TODO filter out annotation targets
-            constantValueGenerator.generateAnnotationConstructorCall(it.annotation)
-        }
 
     private fun translateTypeArguments(arguments: List<TypeProjection>) =
         arguments.map {

compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt

@@ -32,7 +32,6 @@ import org.jetbrains.kotlin.resolve.constants.EnumValue
 import org.jetbrains.kotlin.resolve.constants.IntValue
 import org.jetbrains.kotlin.resolve.constants.NullValue
 import org.jetbrains.kotlin.resolve.constants.StringValue
-import org.jetbrains.kotlin.resolve.descriptorUtil.isSourceAnnotation
 import org.jetbrains.kotlin.resolve.descriptorUtil.nonSourceAnnotations
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
 import org.jetbrains.kotlin.types.*
@@ -752,11 +751,8 @@ class DescriptorSerializer private constructor(
             Variance.OUT_VARIANCE -> ProtoBuf.Type.Argument.Projection.OUT
         }
 
-        private fun hasAnnotations(descriptor: Annotated): Boolean {
+        private fun hasAnnotations(descriptor: Annotated): Boolean =
-            // Sadly, we can't just return `descriptor.nonSourceAnnotations.isNotEmpty()` because that would not
+            descriptor.nonSourceAnnotations.isNotEmpty()
-            // consider use-site-targeted annotations
-            return descriptor.annotations.getAllAnnotations().filterNot { it.annotation.isSourceAnnotation }.isNotEmpty()
-        }
 
         fun <T : DeclarationDescriptor> sort(descriptors: Collection<T>): List<T> =
                 ArrayList(descriptors).apply {

compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt

@@ -1,8 +1,8 @@
 package
 
 public final class A {
-    public constructor A(/*0*/ @Ann @Ann x: kotlin.Int, /*1*/ @RepeatableAnn @Ann y: kotlin.Int)
+    public constructor A(/*0*/ @Ann @Ann x: kotlin.Int, /*1*/ @Ann @RepeatableAnn y: kotlin.Int)
-    @Ann @RepeatableAnn @RepeatableAnn @field:Ann public final val a: kotlin.Int = 0
+    @RepeatableAnn @Ann @RepeatableAnn @field:Ann public final val a: kotlin.Int = 0
     @Ann @Ann @field:Ann public final val b: kotlin.Int = 0
     @field:RepeatableAnn @field:RepeatableAnn public final val c: kotlin.Int = 0
     @RepeatableAnn @RepeatableAnn public final val d: kotlin.Int = 0

compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java

@@ -153,7 +153,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends KotlinTest
     }
 
     private static void checkAnnotationsOnProperty(String expectedAnnotation, PropertyDescriptor prop) {
-        checkDescriptorWithTarget(expectedAnnotation, prop, AnnotationUseSiteTarget.FIELD);
+        checkDescriptor(expectedAnnotation, prop);
         checkDescriptor(expectedAnnotation, prop.getGetter());
         PropertySetterDescriptor propSetter = prop.getSetter();
         assertNotNull(propSetter);
@@ -361,32 +361,15 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends KotlinTest
         return KotlinTestUtils.doLoadFile(file).replaceAll("ANNOTATION", annotationText);
     }
 
-    private static String renderAnnotations(Annotations annotations, @Nullable AnnotationUseSiteTarget defaultTarget) {
+    public static String renderAnnotations(Annotations annotations) {
-        return StringUtil.join(annotations.getAllAnnotations(), annotationWithTarget -> {
+        return StringUtil.join(annotations, annotation -> WITH_ANNOTATION_ARGUMENT_TYPES.renderAnnotation(annotation, null), " ");
-            AnnotationUseSiteTarget targetToRender = annotationWithTarget.getTarget();
-            if (targetToRender == defaultTarget) {
-                targetToRender = null;
-            }
-
-            return WITH_ANNOTATION_ARGUMENT_TYPES.renderAnnotation(annotationWithTarget.getAnnotation(), targetToRender);
-        }, " ");
     }
 
-    protected static void checkDescriptor(String expectedAnnotation, DeclarationDescriptor member) {
+    private static void checkDescriptor(String expectedAnnotation, DeclarationDescriptor member) {
-        String actual = getAnnotations(member);
+        String actual = renderAnnotations(member.getAnnotations());
         assertEquals("Failed to resolve annotation descriptor for " + member.toString(), expectedAnnotation, actual);
     }
 
-    private static void checkDescriptorWithTarget(String expectedAnnotation, DeclarationDescriptor member, AnnotationUseSiteTarget target) {
-        String actual = renderAnnotations(member.getAnnotations(), target);
-        assertEquals("Failed to resolve annotation descriptor for " + member.toString(), expectedAnnotation, actual);
-    }
-
-    @NotNull
-    protected static String getAnnotations(DeclarationDescriptor member) {
-        return renderAnnotations(member.getAnnotations(), null);
-    }
-
     @Override
     public void tearDown() throws Exception {
         analysisResult = null;

compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationParameterTest.kt

@@ -28,7 +28,7 @@ abstract class AbstractAnnotationParameterTest : AbstractAnnotationDescriptorRes
         val classDescriptor = AbstractAnnotationDescriptorResolveTest.getClassDescriptor(packageView, "MyClass")
 
         val expected = InTextDirectivesUtils.findListWithPrefixes(fileText, "// EXPECTED: ").joinToString(", ")
-        val actual = AbstractAnnotationDescriptorResolveTest.getAnnotations(classDescriptor)
+        val actual = AbstractAnnotationDescriptorResolveTest.renderAnnotations(classDescriptor.annotations)
 
         KotlinTestUtils.assertEqualsToFile(File(path), fileText.replace(expected, actual))
     }

core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt

@@ -38,8 +38,6 @@ class LazyJavaAnnotations(
 
     override fun getUseSiteTargetedAnnotations() = emptyList<AnnotationWithTarget>()
 
-    override fun getAllAnnotations() = this.map { AnnotationWithTarget(it, null) }
-
     override fun iterator() =
             (annotationOwner.annotations.asSequence().map(annotationDescriptors)
              + JavaAnnotationMapper.findMappedJavaAnnotation(KotlinBuiltIns.FQ_NAMES.deprecated, annotationOwner, c)).filterNotNull().iterator()

core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt

@@ -198,8 +198,6 @@ private class EnhancedTypeAnnotations(private val fqNameToMatch: FqName) : Annot
         else -> null
     }
 
-    override fun getAllAnnotations() = this.map { AnnotationWithTarget(it, null) }
-
     override fun getUseSiteTargetedAnnotations() = emptyList<AnnotationWithTarget>()
 
     // Note, that this class may break Annotations contract (!isEmpty && iterator.isEmpty())

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

@@ -28,7 +28,6 @@ interface Annotations : Iterable<AnnotationDescriptor> {
      * there may be use-site-targeted annotations applicable to the declaration!
      *
      * @see getUseSiteTargetedAnnotations
-     * @see getAllAnnotations
      */
     fun isEmpty(): Boolean
 
@@ -38,11 +37,6 @@ interface Annotations : Iterable<AnnotationDescriptor> {
 
     fun getUseSiteTargetedAnnotations(): List<AnnotationWithTarget>
 
-    /**
-     * @return both targeted and annotations without target. Annotation order is preserved.
-     */
-    fun getAllAnnotations(): List<AnnotationWithTarget>
-
     companion object {
         val EMPTY: Annotations = object : Annotations {
             override fun isEmpty() = true
@@ -51,8 +45,6 @@ interface Annotations : Iterable<AnnotationDescriptor> {
 
             override fun getUseSiteTargetedAnnotations() = emptyList<AnnotationWithTarget>()
 
-            override fun getAllAnnotations() = emptyList<AnnotationWithTarget>()
-
             override fun iterator() = emptyList<AnnotationDescriptor>().iterator()
 
             override fun toString() = "EMPTY"
@@ -77,10 +69,6 @@ class FilteredAnnotations(
         return delegate.getUseSiteTargetedAnnotations().filter { shouldBeReturned(it.annotation) }
     }
 
-    override fun getAllAnnotations(): List<AnnotationWithTarget> {
-        return delegate.getAllAnnotations().filter { shouldBeReturned(it.annotation) }
-    }
-
     override fun iterator() = delegate.filter(this::shouldBeReturned).iterator()
 
     override fun isEmpty() = delegate.any(this::shouldBeReturned)
@@ -104,8 +92,6 @@ class CompositeAnnotations(
 
     override fun getUseSiteTargetedAnnotations() = delegates.flatMap { it.getUseSiteTargetedAnnotations() }
 
-    override fun getAllAnnotations() = delegates.flatMap { it.getAllAnnotations() }
-
     override fun iterator() = delegates.asSequence().flatMap { it.asSequence() }.iterator()
 }
 

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

@@ -42,8 +42,6 @@ class AnnotationsImpl : Annotations {
                 .map { AnnotationWithTarget(it.annotation, it.target!!) }
     }
 
-    override fun getAllAnnotations() = targetedAnnotations
-
     override fun iterator() = annotations.iterator()
 
     override fun toString() = annotations.toString()

core/descriptors/src/org/jetbrains/kotlin/resolve/annotationsForResolve.kt

@@ -50,6 +50,4 @@ private class AnnotationsWithOnly(val presentAnnotation: FqName): Annotations {
     override fun hasAnnotation(fqName: FqName): Boolean = fqName == this.presentAnnotation
 
     override fun getUseSiteTargetedAnnotations(): List<AnnotationWithTarget> = emptyList()
-
-    override fun getAllAnnotations(): List<AnnotationWithTarget> = emptyList()
 }

core/descriptors/src/org/jetbrains/kotlin/types/KotlinType.kt

@@ -125,8 +125,8 @@ abstract class SimpleType : UnwrappedType() {
 
     override fun toString(): String {
         return buildString {
-            for ((annotation, target) in annotations.getAllAnnotations()) {
+            for (annotation in annotations) {
-                append("[", DescriptorRenderer.DEBUG_TEXT.renderAnnotation(annotation, target), "] ")
+                append("[", DescriptorRenderer.DEBUG_TEXT.renderAnnotation(annotation), "] ")
             }
 
             append(constructor)

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedAnnotations.kt

@@ -33,8 +33,6 @@ open class DeserializedAnnotations(
 
     override fun getUseSiteTargetedAnnotations(): List<AnnotationWithTarget> = emptyList()
 
-    override fun getAllAnnotations(): List<AnnotationWithTarget> = annotations.map { AnnotationWithTarget(it, null) }
-
     override fun iterator(): Iterator<AnnotationDescriptor> = annotations.iterator()
 }
 
@@ -58,8 +56,6 @@ open class DeserializedAnnotationsWithPossibleTargets(
 
     override fun getUseSiteTargetedAnnotations(): List<AnnotationWithTarget> = annotations.filter { it.target != null }
 
-    override fun getAllAnnotations(): List<AnnotationWithTarget> = annotations
-
     override fun iterator(): Iterator<AnnotationDescriptor> {
         return annotations.asSequence().filter { it.target == null }.map { it.annotation }.iterator()
     }

idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/KotlinMultiplatformJUnitRecognizer.kt

@@ -19,16 +19,16 @@ package org.jetbrains.kotlin.idea.run
 import com.intellij.execution.JUnitRecognizer
 import com.intellij.psi.PsiMethod
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
-import org.jetbrains.kotlin.descriptors.ClassifierDescriptorWithTypeParameters
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.idea.caches.project.implementingDescriptors
 import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
 import org.jetbrains.kotlin.idea.project.platform
 import org.jetbrains.kotlin.idea.util.module
 import org.jetbrains.kotlin.platform.impl.isCommon
+import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
@@ -45,13 +45,12 @@ class KotlinMultiplatformJUnitRecognizer : JUnitRecognizer() {
         if (implModules.isEmpty()) return false
 
         val methodDescriptor = origin.resolveToDescriptorIfAny() ?: return false
-        return methodDescriptor.annotations.getAllAnnotations().any { it.isExpectOfAnnotation("org.junit.Test", implModules) }
+        return methodDescriptor.annotations.any { it.isExpectOfAnnotation("org.junit.Test", implModules) }
-
     }
 }
 
-private fun AnnotationWithTarget.isExpectOfAnnotation(fqName: String, implModules: Collection<ModuleDescriptor>): Boolean {
+private fun AnnotationDescriptor.isExpectOfAnnotation(fqName: String, implModules: Collection<ModuleDescriptor>): Boolean {
-    val annotationClass = annotation.type.constructor.declarationDescriptor as? ClassifierDescriptorWithTypeParameters ?: return false
+    val annotationClass = annotationClass ?: return false
     if (!annotationClass.isExpect) return false
     val classId = annotationClass.classId ?: return false
     val segments = classId.relativeClassName.pathSegments()

idea/src/org/jetbrains/kotlin/idea/parameterInfo/KotlinFunctionParameterInfoHandler.kt

@@ -32,7 +32,6 @@ import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.core.OptionalParametersHelper
 import org.jetbrains.kotlin.idea.core.resolveCandidates
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
-import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShadowedDeclarationsFilter
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.NULLABILITY_ANNOTATIONS
@@ -259,10 +258,9 @@ abstract class KotlinParameterInfoWithCallHandlerBase<TArgumentList : KtElement,
 
             parameter
                 .annotations
-                .getAllAnnotations()
+                .filterNot { it.fqName in NULLABILITY_ANNOTATIONS }
-                .filterNot { it.annotation.fqName in NULLABILITY_ANNOTATIONS }
                 .forEach {
-                    it.annotation.fqName?.let { append("@${it.shortName().asString()} ") }
+                    it.fqName?.let { fqName -> append("@${fqName.shortName().asString()} ") }
                 }
 
             if (parameter.varargElementType != null) {

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsRuntimeAnnotationChecker.kt

@@ -20,8 +20,8 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.MemberDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention
 import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.resolve.checkers.DeclarationCheckerContext
 import org.jetbrains.kotlin.resolve.checkers.DeclarationChecker
+import org.jetbrains.kotlin.resolve.checkers.DeclarationCheckerContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.getAnnotationRetention
 import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal
@@ -29,16 +29,15 @@ import org.jetbrains.kotlin.resolve.source.PsiSourceElement
 
 object JsRuntimeAnnotationChecker : DeclarationChecker {
     override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) {
-        for ((annotationDescriptor, _) in descriptor.annotations.getAllAnnotations()) {
+        for (annotation in descriptor.annotations) {
-            val annotationClass = annotationDescriptor.annotationClass ?: continue
+            val annotationClass = annotation.annotationClass ?: continue
             if (annotationClass.getAnnotationRetention() != KotlinRetention.RUNTIME) continue
 
-            val annotationPsi = (annotationDescriptor.source as? PsiSourceElement)?.psi ?: declaration
+            val annotationPsi = (annotation.source as? PsiSourceElement)?.psi ?: declaration
 
             if (descriptor is MemberDescriptor && descriptor.isEffectivelyExternal()) {
                 context.trace.report(ErrorsJs.RUNTIME_ANNOTATION_ON_EXTERNAL_DECLARATION.on(annotationPsi))
-            }
+            } else {
-            else {
                 context.trace.report(ErrorsJs.RUNTIME_ANNOTATION_NOT_SUPPORTED.on(annotationPsi))
             }
         }

plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableAnnotationChecker.kt

@@ -88,10 +88,10 @@ class ParcelableAnnotationChecker : CallChecker {
         val descriptor = context.trace[BindingContext.DECLARATION_TO_DESCRIPTOR, element] ?: return
         val thisMappedType = resolvedCall.typeArguments.values.takeIf { it.size == 2 }?.first() ?: return
 
-        val duplicatingAnnotationCount = descriptor.annotations.getAllAnnotations()
+        val duplicatingAnnotationCount = descriptor.annotations
-                .filter { it.annotation.fqName == TYPE_PARCELER_FQNAME }
+            .filter { it.fqName == TYPE_PARCELER_FQNAME }
-                .mapNotNull { it.annotation.type.arguments.takeIf { it.size == 2 }?.first()?.type }
+            .mapNotNull { it.type.arguments.takeIf { args -> args.size == 2 }?.first()?.type }
-                .count { it == thisMappedType }
+            .count { it == thisMappedType }
 
         if (duplicatingAnnotationCount > 1) {
             val reportElement = annotationEntry.typeArguments.firstOrNull() ?: annotationEntry

plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableDeclarationChecker.kt

@@ -19,8 +19,6 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.reportFromPlugin
@@ -88,10 +86,7 @@ class ParcelableDeclarationChecker : DeclarationChecker {
             bindingContext: BindingContext
     ) {
         fun hasIgnoredOnParcel(): Boolean {
-            fun AnnotationDescriptor.isIgnoredOnParcel() = fqName == IGNORED_ON_PARCEL_FQNAME
+            fun Annotations.hasIgnoredOnParcel() = any { it.fqName == IGNORED_ON_PARCEL_FQNAME }
-
-            fun Annotations.hasIgnoredOnParcel() = getAllAnnotations()
-                .any { (it.target == null || it.target == AnnotationUseSiteTarget.PROPERTY_GETTER) && it.annotation.isIgnoredOnParcel() }
 
             return property.annotations.hasIgnoredOnParcel() || (property.getter?.annotations?.hasIgnoredOnParcel() ?: false)
         }