From 87c0d566186e2c33d19fcb8f8add29dcecb47a0b Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 16 Aug 2018 12:18:36 +0200 Subject: [PATCH] Drop Annotations.getAllAnnotations --- .../kotlin/codegen/MemberCodegen.java | 2 +- .../kotlin/codegen/PropertyCodegen.java | 2 +- .../annotations/AnnotationSplitter.kt | 22 ++++++++------- .../kotlin/resolve/lazy/ForceResolveUtil.java | 6 ++--- .../lazy/descriptors/LazyAnnotations.kt | 7 +++-- .../kotlin/ir/util/TypeTranslator.kt | 7 ++--- .../serialization/DescriptorSerializer.kt | 8 ++---- .../withUseSiteTarget/repeatable.txt | 4 +-- ...stractAnnotationDescriptorResolveTest.java | 27 ++++--------------- .../AbstractAnnotationParameterTest.kt | 2 +- .../load/java/lazy/LazyJavaAnnotations.kt | 2 -- .../java/typeEnhancement/typeEnhancement.kt | 2 -- .../descriptors/annotations/Annotations.kt | 14 ---------- .../annotations/AnnotationsImpl.kt | 2 -- .../kotlin/resolve/annotationsForResolve.kt | 2 -- .../org/jetbrains/kotlin/types/KotlinType.kt | 4 +-- .../descriptors/DeserializedAnnotations.kt | 4 --- .../run/KotlinMultiplatformJUnitRecognizer.kt | 11 ++++---- .../KotlinFunctionParameterInfoHandler.kt | 6 ++--- .../diagnostics/JsRuntimeAnnotationChecker.kt | 11 ++++---- .../parcel/ParcelableAnnotationChecker.kt | 8 +++--- .../parcel/ParcelableDeclarationChecker.kt | 7 +---- 22 files changed, 51 insertions(+), 109 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java index 9e68c622a2a..662afe79bb3 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java @@ -245,7 +245,7 @@ public abstract class MemberCodegen - 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 { 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 + } } } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt index 126cde25ffa..3f8d1d8fd22 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt @@ -109,10 +109,7 @@ class TypeTranslator( } private fun translateTypeAnnotations(annotations: Annotations): List = - annotations.getAllAnnotations().map { - // TODO filter out annotation targets - constantValueGenerator.generateAnnotationConstructorCall(it.annotation) - } + annotations.map(constantValueGenerator::generateAnnotationConstructorCall) private fun translateTypeArguments(arguments: List) = arguments.map { @@ -121,4 +118,4 @@ class TypeTranslator( else translateType(it.type, it.projectionKind) } -} \ No newline at end of file +} diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt index 5944c196154..5c3d89eef56 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt +++ b/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 { - // Sadly, we can't just return `descriptor.nonSourceAnnotations.isNotEmpty()` because that would not - // consider use-site-targeted annotations - return descriptor.annotations.getAllAnnotations().filterNot { it.annotation.isSourceAnnotation }.isNotEmpty() - } + private fun hasAnnotations(descriptor: Annotated): Boolean = + descriptor.nonSourceAnnotations.isNotEmpty() fun sort(descriptors: Collection): List = ArrayList(descriptors).apply { diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt index 05fd78fb215..288d9cc6352 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt +++ b/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) - @Ann @RepeatableAnn @RepeatableAnn @field:Ann public final val a: kotlin.Int = 0 + public constructor A(/*0*/ @Ann @Ann x: kotlin.Int, /*1*/ @Ann @RepeatableAnn y: kotlin.Int) + @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 diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java index 751261d2ad5..778b8dc1f44 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java +++ b/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) { - return StringUtil.join(annotations.getAllAnnotations(), annotationWithTarget -> { - AnnotationUseSiteTarget targetToRender = annotationWithTarget.getTarget(); - if (targetToRender == defaultTarget) { - targetToRender = null; - } - - return WITH_ANNOTATION_ARGUMENT_TYPES.renderAnnotation(annotationWithTarget.getAnnotation(), targetToRender); - }, " "); + public static String renderAnnotations(Annotations annotations) { + return StringUtil.join(annotations, annotation -> WITH_ANNOTATION_ARGUMENT_TYPES.renderAnnotation(annotation, null), " "); } - protected static void checkDescriptor(String expectedAnnotation, DeclarationDescriptor member) { - String actual = getAnnotations(member); + private static void checkDescriptor(String expectedAnnotation, DeclarationDescriptor 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; diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationParameterTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationParameterTest.kt index 92ab023ecfa..375ba2af348 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationParameterTest.kt +++ b/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)) } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt index f6ba101ffff..31a542db952 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt @@ -38,8 +38,6 @@ class LazyJavaAnnotations( override fun getUseSiteTargetedAnnotations() = emptyList() - 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() diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt index bafc8aa5243..d70e80b648f 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt +++ b/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() // Note, that this class may break Annotations contract (!isEmpty && iterator.isEmpty()) 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 a5174550d4e..a937a8de4bf 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt @@ -28,7 +28,6 @@ interface Annotations : Iterable { * 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 { fun getUseSiteTargetedAnnotations(): List - /** - * @return both targeted and annotations without target. Annotation order is preserved. - */ - fun getAllAnnotations(): List - companion object { val EMPTY: Annotations = object : Annotations { override fun isEmpty() = true @@ -51,8 +45,6 @@ interface Annotations : Iterable { override fun getUseSiteTargetedAnnotations() = emptyList() - override fun getAllAnnotations() = emptyList() - override fun iterator() = emptyList().iterator() override fun toString() = "EMPTY" @@ -77,10 +69,6 @@ class FilteredAnnotations( return delegate.getUseSiteTargetedAnnotations().filter { shouldBeReturned(it.annotation) } } - override fun getAllAnnotations(): List { - 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() } 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 bcb4cb5a0ba..c02013fac21 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationsImpl.kt +++ b/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() diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/annotationsForResolve.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/annotationsForResolve.kt index f0c959dc02a..5aac2ee4397 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/annotationsForResolve.kt +++ b/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 = emptyList() - - override fun getAllAnnotations(): List = emptyList() } diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/KotlinType.kt b/core/descriptors/src/org/jetbrains/kotlin/types/KotlinType.kt index 25232e74673..cceb0229a64 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/KotlinType.kt +++ b/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()) { - append("[", DescriptorRenderer.DEBUG_TEXT.renderAnnotation(annotation, target), "] ") + for (annotation in annotations) { + append("[", DescriptorRenderer.DEBUG_TEXT.renderAnnotation(annotation), "] ") } append(constructor) 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 469e11274c3..865ffe8231c 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 @@ -33,8 +33,6 @@ open class DeserializedAnnotations( override fun getUseSiteTargetedAnnotations(): List = emptyList() - override fun getAllAnnotations(): List = annotations.map { AnnotationWithTarget(it, null) } - override fun iterator(): Iterator = annotations.iterator() } @@ -58,8 +56,6 @@ open class DeserializedAnnotationsWithPossibleTargets( override fun getUseSiteTargetedAnnotations(): List = annotations.filter { it.target != null } - override fun getAllAnnotations(): List = annotations - override fun iterator(): Iterator { return annotations.asSequence().filter { it.target == null }.map { it.annotation }.iterator() } diff --git a/idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/KotlinMultiplatformJUnitRecognizer.kt b/idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/KotlinMultiplatformJUnitRecognizer.kt index 229b64b9ab8..93785800acd 100644 --- a/idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/KotlinMultiplatformJUnitRecognizer.kt +++ b/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): Boolean { - val annotationClass = annotation.type.constructor.declarationDescriptor as? ClassifierDescriptorWithTypeParameters ?: return false +private fun AnnotationDescriptor.isExpectOfAnnotation(fqName: String, implModules: Collection): Boolean { + val annotationClass = annotationClass ?: return false if (!annotationClass.isExpect) return false val classId = annotationClass.classId ?: return false val segments = classId.relativeClassName.pathSegments() diff --git a/idea/src/org/jetbrains/kotlin/idea/parameterInfo/KotlinFunctionParameterInfoHandler.kt b/idea/src/org/jetbrains/kotlin/idea/parameterInfo/KotlinFunctionParameterInfoHandler.kt index d385309cc70..915ff3aaa73 100644 --- a/idea/src/org/jetbrains/kotlin/idea/parameterInfo/KotlinFunctionParameterInfoHandler.kt +++ b/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 append("@${fqName.shortName().asString()} ") } } if (parameter.varargElementType != null) { diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsRuntimeAnnotationChecker.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsRuntimeAnnotationChecker.kt index e7a6ef80399..754a2859334 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsRuntimeAnnotationChecker.kt +++ b/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()) { - val annotationClass = annotationDescriptor.annotationClass ?: continue + for (annotation in descriptor.annotations) { + 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)) } } diff --git a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableAnnotationChecker.kt b/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableAnnotationChecker.kt index b7eebb01b88..6ec7b583839 100644 --- a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableAnnotationChecker.kt +++ b/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() - .filter { it.annotation.fqName == TYPE_PARCELER_FQNAME } - .mapNotNull { it.annotation.type.arguments.takeIf { it.size == 2 }?.first()?.type } - .count { it == thisMappedType } + val duplicatingAnnotationCount = descriptor.annotations + .filter { it.fqName == TYPE_PARCELER_FQNAME } + .mapNotNull { it.type.arguments.takeIf { args -> args.size == 2 }?.first()?.type } + .count { it == thisMappedType } if (duplicatingAnnotationCount > 1) { val reportElement = annotationEntry.typeArguments.firstOrNull() ?: annotationEntry diff --git a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableDeclarationChecker.kt b/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableDeclarationChecker.kt index a828a1d6ede..f14d05d07c0 100644 --- a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableDeclarationChecker.kt +++ b/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() = getAllAnnotations() - .any { (it.target == null || it.target == AnnotationUseSiteTarget.PROPERTY_GETTER) && it.annotation.isIgnoredOnParcel() } + fun Annotations.hasIgnoredOnParcel() = any { it.fqName == IGNORED_ON_PARCEL_FQNAME } return property.annotations.hasIgnoredOnParcel() || (property.getter?.annotations?.hasIgnoredOnParcel() ?: false) }