Use a single AnnotatedCallableKind enum item for property

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

@@ -192,8 +192,12 @@ public class DescriptorSerializer {
             hasConstant = !(compileTimeConstant == null || compileTimeConstant instanceof NullValue);
         }
 
+        boolean hasAnnotations = (descriptor instanceof PropertyDescriptor)
+                                 ? !descriptor.getAnnotations().getAllAnnotations().isEmpty()
+                                 : hasAnnotations(descriptor);
+
         builder.setFlags(Flags.getCallableFlags(
-                hasAnnotations(descriptor),
+                hasAnnotations,
                 descriptor.getVisibility(),
                 descriptor.getModality(),
                 descriptor.getKind(),

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt

@@ -34,14 +34,11 @@ import org.jetbrains.kotlin.types.JetType
 import java.util.ArrayList
 import java.util.HashMap
 
-import org.jetbrains.kotlin.serialization.deserialization.AnnotatedCallableKind.PROPERTY_SYNTHETIC_FUNCTION
+public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C : Any, T : Any>(
-import org.jetbrains.kotlin.serialization.deserialization.AnnotatedCallableKind.PROPERTY_FIELD
-
-public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C : Any>(
         storageManager: StorageManager,
         private val kotlinClassFinder: KotlinClassFinder,
         private val errorReporter: ErrorReporter
-) : AnnotationAndConstantLoader<A, C> {
+) : AnnotationAndConstantLoader<A, C, T> {
     private val storage = storageManager.createMemoizedFunction<KotlinJvmBinaryClass, Storage<A, C>> {
         kotlinClass ->
         loadAnnotationsAndInitializers(kotlinClass)
@@ -96,19 +93,38 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
             proto: ProtoBuf.Callable,
             nameResolver: NameResolver,
             kind: AnnotatedCallableKind
-    ): List<A> {
+    ): List<T> {
+        if (kind == AnnotatedCallableKind.PROPERTY) {
+            val syntheticFunctionSignature = getPropertySignature(proto, nameResolver, synthetic = true)
+            val fieldSignature = getPropertySignature(proto, nameResolver, field = true)
+
+            val propertyAnnotations = syntheticFunctionSignature?.let { sig ->
+                findClassAndLoadMemberAnnotations(container, proto, nameResolver, kind, sig, false)
+            } ?: listOf()
+
+            val fieldAnnotations = fieldSignature?.let { sig ->
+                findClassAndLoadMemberAnnotations(container, proto, nameResolver, kind, sig)
+            } ?: listOf()
+
+            return loadPropertyAnnotations(propertyAnnotations, fieldAnnotations)
+        }
         val signature = getCallableSignature(proto, nameResolver, kind) ?: return listOf()
-        return findClassAndLoadMemberAnnotations(container, proto, nameResolver, kind, signature)
+        return transformAnnotations(findClassAndLoadMemberAnnotations(container, proto, nameResolver, kind, signature))
     }
 
+    protected abstract fun loadPropertyAnnotations(propertyAnnotations: List<A>, fieldAnnotations: List<A>): List<T>
+
+    protected abstract fun transformAnnotations(annotations: List<A>): List<T>
+
     private fun findClassAndLoadMemberAnnotations(
             container: ProtoContainer,
             proto: ProtoBuf.Callable,
             nameResolver: NameResolver,
             kind: AnnotatedCallableKind,
-            signature: MemberSignature
+            signature: MemberSignature,
+            seekForStaticFieldInOuter: Boolean = true
     ): List<A> {
-        val kotlinClass = findClassWithAnnotationsAndInitializers(container, proto, nameResolver, kind)
+        val kotlinClass = findClassWithAnnotationsAndInitializers(container, proto, nameResolver, kind, seekForStaticFieldInOuter)
         if (kotlinClass == null) {
             errorReporter.reportLoadingError("Kotlin class for loading member annotations is not found: ${container.getFqName(nameResolver)}", null)
             return listOf()
@@ -176,7 +192,8 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
             container: ProtoContainer,
             proto: ProtoBuf.Callable,
             nameResolver: NameResolver,
-            annotatedCallableKind: AnnotatedCallableKind
+            annotatedCallableKind: AnnotatedCallableKind,
+            seekForStaticFieldInOuter: Boolean = true
     ): KotlinJvmBinaryClass? {
         val packageFqName = container.packageFqName
         if (packageFqName != null) {
@@ -186,13 +203,11 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
         val classKind = Flags.CLASS_KIND[classProto.getFlags()]
         val classId = nameResolver.getClassId(classProto.getFqName())
 
-        if (classKind == ProtoBuf.Class.Kind.CLASS_OBJECT && isStaticFieldInOuter(proto)
+        if (classKind == ProtoBuf.Class.Kind.CLASS_OBJECT && isStaticFieldInOuter(proto) && seekForStaticFieldInOuter) {
-                && annotatedCallableKind != AnnotatedCallableKind.PROPERTY_SYNTHETIC_FUNCTION) {
             // Backing fields of properties of a companion object are generated in the outer class
             return kotlinClassFinder.findKotlinClass(classId.getOuterClassId())
         }
-        else if (classKind == ProtoBuf.Class.Kind.TRAIT &&
+        else if (classKind == ProtoBuf.Class.Kind.TRAIT && (annotatedCallableKind == AnnotatedCallableKind.PROPERTY)) {
-                 (annotatedCallableKind == PROPERTY_SYNTHETIC_FUNCTION || annotatedCallableKind == PROPERTY_FIELD)) {
             if (proto.hasExtension(implClassName)) {
                 val parentPackageFqName = classId.getPackageFqName()
                 val tImplName = nameResolver.getName(proto.getExtension(implClassName))
@@ -276,50 +291,54 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
         return Storage(memberAnnotations, propertyConstants)
     }
 
-    private class Storage<A, C>(
+    private fun getPropertySignature(
-            public val memberAnnotations: Map<MemberSignature, List<A>>,
+            proto: ProtoBuf.Callable,
-            public val propertyConstants: Map<MemberSignature, C>
+            nameResolver: NameResolver,
-    )
+            field: Boolean = false,
-}
+            synthetic: Boolean = false
-
+    ): MemberSignature? {
-private fun getCallableSignature(
-        proto: ProtoBuf.Callable,
-        nameResolver: NameResolver,
-        kind: AnnotatedCallableKind
-): MemberSignature? {
-    val deserializer = SignatureDeserializer(nameResolver)
-
-    fun getPropertySignature(handleField: Boolean = false, handleSynthetic: Boolean = false): MemberSignature? {
         if (!proto.hasExtension(propertySignature)) return null
 
         val propertySignature = proto.getExtension(propertySignature)
+        val deserializer = SignatureDeserializer(nameResolver)
 
-        if (handleField && propertySignature.hasField()) {
+        if (field && propertySignature.hasField()) {
-            val field = propertySignature.getField()
+            val field = propertySignature.field
-            val type = deserializer.typeDescriptor(field.getType())
+            val type = deserializer.typeDescriptor(field.type)
-            val name = nameResolver.getName(field.getName())
+            val name = nameResolver.getName(field.name)
             return MemberSignature.fromFieldNameAndDesc(name, type)
         }
-        else if (handleSynthetic && propertySignature.hasSyntheticMethod()) {
+        else if (synthetic && propertySignature.hasSyntheticMethod()) {
-            return deserializer.methodSignature(propertySignature.getSyntheticMethod())
+            return deserializer.methodSignature(propertySignature.syntheticMethod)
         }
 
         return null
     }
 
-    when (kind) {
+    private fun getCallableSignature(
-        AnnotatedCallableKind.FUNCTION -> if (proto.hasExtension(methodSignature)) {
+            proto: ProtoBuf.Callable,
-            return deserializer.methodSignature(proto.getExtension(methodSignature))
+            nameResolver: NameResolver,
+            kind: AnnotatedCallableKind
+    ): MemberSignature? {
+        val deserializer = SignatureDeserializer(nameResolver)
+
+        when (kind) {
+            AnnotatedCallableKind.FUNCTION -> if (proto.hasExtension(methodSignature)) {
+                return deserializer.methodSignature(proto.getExtension(methodSignature))
+            }
+            AnnotatedCallableKind.PROPERTY_GETTER -> if (proto.hasExtension(propertySignature)) {
+                return deserializer.methodSignature(proto.getExtension(propertySignature).getGetter())
+            }
+            AnnotatedCallableKind.PROPERTY_SETTER -> if (proto.hasExtension(propertySignature)) {
+                return deserializer.methodSignature(proto.getExtension(propertySignature).getSetter())
+            }
+            AnnotatedCallableKind.PROPERTY -> return getPropertySignature(proto, nameResolver, true, true)
         }
-        AnnotatedCallableKind.PROPERTY_GETTER -> if (proto.hasExtension(propertySignature)) {
+        return null
-            return deserializer.methodSignature(proto.getExtension(propertySignature).getGetter())
-        }
-        AnnotatedCallableKind.PROPERTY_SETTER -> if (proto.hasExtension(propertySignature)) {
-            return deserializer.methodSignature(proto.getExtension(propertySignature).getSetter())
-        }
-        AnnotatedCallableKind.PROPERTY -> return getPropertySignature(true, true)
-        AnnotatedCallableKind.PROPERTY_FIELD -> return getPropertySignature(handleField = true)
-        AnnotatedCallableKind.PROPERTY_SYNTHETIC_FUNCTION -> return getPropertySignature(handleSynthetic = true)
     }
-    return null
+
-}
+    private class Storage<A, C>(
+            public val memberAnnotations: Map<MemberSignature, List<A>>,
+            public val propertyConstants: Map<MemberSignature, C>
+    )
+}

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt

@@ -19,6 +19,8 @@ package org.jetbrains.kotlin.load.kotlin
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
 import org.jetbrains.kotlin.load.java.components.DescriptorResolverUtils
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass.AnnotationArrayArgumentVisitor
 import org.jetbrains.kotlin.name.ClassId
@@ -42,7 +44,7 @@ public class BinaryClassAnnotationAndConstantLoaderImpl(
         storageManager: StorageManager,
         kotlinClassFinder: KotlinClassFinder,
         errorReporter: ErrorReporter
-) : AbstractBinaryClassAnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>>(
+) : AbstractBinaryClassAnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>, AnnotationWithTarget>(
         storageManager, kotlinClassFinder, errorReporter
 ) {
     private val annotationDeserializer = AnnotationDeserializer(module)
@@ -81,6 +83,18 @@ public class BinaryClassAnnotationAndConstantLoaderImpl(
         return factory.createConstantValue(normalizedValue)
     }
 
+    override fun loadPropertyAnnotations(
+            propertyAnnotations: List<AnnotationDescriptor>,
+            fieldAnnotations: List<AnnotationDescriptor>
+    ): List<AnnotationWithTarget> {
+        return propertyAnnotations.map { AnnotationWithTarget(it, null) } +
+               fieldAnnotations.map { AnnotationWithTarget(it, AnnotationUseSiteTarget.FIELD) }
+    }
+
+    override fun transformAnnotations(annotations: List<AnnotationDescriptor>): List<AnnotationWithTarget> {
+        return annotations.map { AnnotationWithTarget(it, null) }
+    }
+
     override fun loadAnnotation(
             annotationClassId: ClassId,
             source: SourceElement,

core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.builtins
 
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf
@@ -26,7 +27,7 @@ import org.jetbrains.kotlin.types.JetType
 
 class BuiltInsAnnotationAndConstantLoader(
         module: ModuleDescriptor
-) : AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>> {
+) : AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>, AnnotationWithTarget> {
     private val deserializer = AnnotationDeserializer(module)
 
     override fun loadClassAnnotations(
@@ -42,10 +43,9 @@ class BuiltInsAnnotationAndConstantLoader(
             proto: ProtoBuf.Callable,
             nameResolver: NameResolver,
             kind: AnnotatedCallableKind
-    ): List<AnnotationDescriptor> {
+    ): List<AnnotationWithTarget> {
-        if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList()
         val annotations = proto.getExtension(BuiltInsProtoBuf.callableAnnotation).orEmpty()
-        return annotations.map { proto -> deserializer.deserializeAnnotation(proto, nameResolver) }
+        return annotations.map { proto -> AnnotationWithTarget(deserializer.deserializeAnnotation(proto, nameResolver), null) }
     }
 
     override fun loadValueParameterAnnotations(

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotatedCallableKind.java

@@ -19,8 +19,6 @@ package org.jetbrains.kotlin.serialization.deserialization;
 public enum AnnotatedCallableKind {
     FUNCTION,
     PROPERTY,
-    PROPERTY_SYNTHETIC_FUNCTION,
-    PROPERTY_FIELD,
     PROPERTY_GETTER,
     PROPERTY_SETTER
 }

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.types.JetType;
 
 import java.util.List;
 
-public interface AnnotationAndConstantLoader<A, C> {
+public interface AnnotationAndConstantLoader<A, C, T> {
     @NotNull
     List<A> loadClassAnnotations(
             @NotNull ProtoBuf.Class classProto,
@@ -31,7 +31,7 @@ public interface AnnotationAndConstantLoader<A, C> {
     );
 
     @NotNull
-    List<A> loadCallableAnnotations(
+    List<T> loadCallableAnnotations(
             @NotNull ProtoContainer container,
             @NotNull ProtoBuf.Callable proto,
             @NotNull NameResolver nameResolver,

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.serialization.deserialization
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
@@ -48,7 +47,7 @@ public class MemberDeserializer(private val c: DeserializationContext) {
 
         val property = DeserializedPropertyDescriptor(
                 c.containingDeclaration, null,
-                getPropertyAnnotations(proto),
+                getAnnotations(proto, flags, AnnotatedCallableKind.PROPERTY),
                 modality(Flags.MODALITY.get(flags)),
                 visibility(Flags.VISIBILITY.get(flags)),
                 Flags.CALLABLE_KIND.get(flags) == Callable.CallableKind.VAR,
@@ -178,31 +177,13 @@ public class MemberDeserializer(private val c: DeserializationContext) {
         if (!Flags.HAS_ANNOTATIONS.get(flags)) {
             return Annotations.EMPTY
         }
-        return DeserializedAnnotations(c.storageManager) {
+        return DeserializedAnnotationsWithPossibleTargets(c.storageManager) {
             c.components.annotationAndConstantLoader.loadCallableAnnotations(
                     c.containingDeclaration.asProtoContainer(), proto, c.nameResolver, kind
             )
         }
     }
 
-    private fun getPropertyAnnotations(proto: Callable): Annotations {
-        return DeserializedAnnotationsWithPossibleTargets(c.storageManager) {
-            val annotations = arrayListOf<AnnotationWithTarget>()
-            val container = c.containingDeclaration.asProtoContainer()
-
-            fun loadAnnotations(kind: AnnotatedCallableKind, mapper: (AnnotationDescriptor) -> AnnotationWithTarget) {
-                annotations += c.components.annotationAndConstantLoader.loadCallableAnnotations(
-                        container, proto, c.nameResolver, kind
-                ).map(mapper)
-            }
-
-            loadAnnotations(AnnotatedCallableKind.PROPERTY_SYNTHETIC_FUNCTION) { AnnotationWithTarget(it, null) }
-            loadAnnotations(AnnotatedCallableKind.PROPERTY_FIELD) { AnnotationWithTarget(it, AnnotationUseSiteTarget.FIELD) }
-
-            annotations
-        }
-    }
-
     private fun getReceiverParameterAnnotations(
             proto: Callable,
             kind: AnnotatedCallableKind,
@@ -251,9 +232,4 @@ public class MemberDeserializer(private val c: DeserializationContext) {
         is DeserializedClassDescriptor -> ProtoContainer(classProto, null)
         else -> error("Only members in classes or package fragments should be serialized: $this")
     }
-
-    private companion object {
-        val CONSTRUCTOR_PARAMETER_ANNOTATION_MAPPER =
-                { a: AnnotationDescriptor -> AnnotationWithTarget(a, AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER) }
-    }
 }

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/context.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.serialization.deserialization
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.serialization.ProtoBuf
@@ -27,7 +28,7 @@ public class DeserializationComponents(
         public val storageManager: StorageManager,
         public val moduleDescriptor: ModuleDescriptor,
         public val classDataFinder: ClassDataFinder,
-        public val annotationAndConstantLoader: AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>>,
+        public val annotationAndConstantLoader: AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>, AnnotationWithTarget>,
         public val packageFragmentProvider: PackageFragmentProvider,
         public val localClassResolver: LocalClassResolver,
         public val flexibleTypeCapabilitiesDeserializer: FlexibleTypeCapabilitiesDeserializer,

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/AnnotationLoaderForKotlinJavaScriptStubBuilder.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.idea.decompiler
 
+import org.jetbrains.kotlin.idea.decompiler.stubBuilder.ClassIdWithTarget
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.AnnotatedCallableKind
@@ -25,7 +26,7 @@ import org.jetbrains.kotlin.serialization.deserialization.ProtoContainer
 import org.jetbrains.kotlin.serialization.js.JsProtoBuf
 import org.jetbrains.kotlin.types.JetType
 
-public class AnnotationLoaderForKotlinJavaScriptStubBuilder() : AnnotationAndConstantLoader<ClassId, Unit> {
+public class AnnotationLoaderForKotlinJavaScriptStubBuilder() : AnnotationAndConstantLoader<ClassId, Unit, ClassIdWithTarget> {
 
     override fun loadClassAnnotations(
             classProto: ProtoBuf.Class, nameResolver: NameResolver
@@ -37,9 +38,8 @@ public class AnnotationLoaderForKotlinJavaScriptStubBuilder() : AnnotationAndCon
             proto: ProtoBuf.Callable,
             nameResolver: NameResolver,
             kind: AnnotatedCallableKind
-    ): List<ClassId> {
+    ): List<ClassIdWithTarget> {
-        if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList()
+        return proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty().map { ClassIdWithTarget(nameResolver.getClassId(it.id), null) }
-        return proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty().map { nameResolver.getClassId(it.getId()) }
     }
 
     override fun loadValueParameterAnnotations(

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt

@@ -102,23 +102,9 @@ private class CallableClsStubBuilder(
 
         val modifierListStubImpl = createModifierListStubForDeclaration(callableStub, callableProto.getFlags(), relevantModifiers)
 
-        fun createAnnotationStubs(kind: AnnotatedCallableKind) {
-            val annotationIds = c.components.annotationLoader.loadCallableAnnotations(protoContainer, callableProto, c.nameResolver, kind)
-            val target = if (kind == AnnotatedCallableKind.PROPERTY_FIELD) AnnotationUseSiteTarget.FIELD else null
-            createAnnotationStubs(annotationIds,
-                                  modifierListStubImpl,
-                                  needWrappingAnnotationEntries = isPrimaryConstructor,
-                                  target = target)
-        }
-
         val kind = callableProto.annotatedCallableKind
-        if (kind == AnnotatedCallableKind.PROPERTY) {
+        val annotationIds = c.components.annotationLoader.loadCallableAnnotations(protoContainer, callableProto, c.nameResolver, kind)
-            createAnnotationStubs(AnnotatedCallableKind.PROPERTY_SYNTHETIC_FUNCTION)
+        createTargetedAnnotationStubs(annotationIds, modifierListStubImpl, needWrappingAnnotationEntries = isPrimaryConstructor)
-            createAnnotationStubs(AnnotatedCallableKind.PROPERTY_FIELD)
-        }
-        else {
-            createAnnotationStubs(kind)
-        }
     }
 
     private fun doCreateCallableStub(): StubElement<out PsiElement> {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderContext.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.idea.decompiler.stubBuilder
 
 import org.jetbrains.kotlin.descriptors.SourceElement
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.load.kotlin.AbstractBinaryClassAnnotationAndConstantLoader
 import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass
@@ -31,9 +32,11 @@ import org.jetbrains.kotlin.serialization.deserialization.NameResolver
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 
+data class ClassIdWithTarget(val classId: ClassId, val target: AnnotationUseSiteTarget?)
+
 class ClsStubBuilderComponents(
         val classDataFinder: ClassDataFinder,
-        val annotationLoader: AnnotationAndConstantLoader<ClassId, Unit>
+        val annotationLoader: AnnotationAndConstantLoader<ClassId, Unit, ClassIdWithTarget>
 ) {
     fun createContext(
             nameResolver: NameResolver,
@@ -92,7 +95,7 @@ private fun ClsStubBuilderContext.child(nameResolver: NameResolver): ClsStubBuil
 class AnnotationLoaderForStubBuilder(
         kotlinClassFinder: KotlinClassFinder,
         errorReporter: ErrorReporter
-) : AbstractBinaryClassAnnotationAndConstantLoader<ClassId, Unit>(
+) : AbstractBinaryClassAnnotationAndConstantLoader<ClassId, Unit, ClassIdWithTarget>(
         LockBasedStorageManager.NO_LOCKS, kotlinClassFinder, errorReporter) {
 
     override fun loadClassAnnotations(
@@ -116,4 +119,11 @@ class AnnotationLoaderForStubBuilder(
         result.add(annotationClassId)
         return null
     }
+
+    override fun loadPropertyAnnotations(propertyAnnotations: List<ClassId>, fieldAnnotations: List<ClassId>): List<ClassIdWithTarget> {
+        return propertyAnnotations.map { ClassIdWithTarget(it, null) } +
+               fieldAnnotations.map { ClassIdWithTarget(it, AnnotationUseSiteTarget.FIELD) }
+    }
+
+    override fun transformAnnotations(annotations: List<ClassId>) = annotations.map { ClassIdWithTarget(it, null) }
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt

@@ -171,11 +171,14 @@ fun createModifierListStub(
     )
 }
 
-fun createAnnotationStubs(
+fun createAnnotationStubs(annotationIds: List<ClassId>, parent: KotlinStubBaseImpl<*>, needWrappingAnnotationEntries: Boolean = false) {
-        annotationIds: List<ClassId>,
+    return createTargetedAnnotationStubs(annotationIds.map { ClassIdWithTarget(it, null) }, parent, needWrappingAnnotationEntries)
+}
+
+fun createTargetedAnnotationStubs(
+        annotationIds: List<ClassIdWithTarget>,
         parent: KotlinStubBaseImpl<*>,
-        needWrappingAnnotationEntries: Boolean = false,
+        needWrappingAnnotationEntries: Boolean = false
-        target: AnnotationUseSiteTarget? = null
 ) {
     if (annotationIds.isEmpty()) return
 
@@ -183,8 +186,8 @@ fun createAnnotationStubs(
             if (needWrappingAnnotationEntries) KotlinPlaceHolderStubImpl<JetAnnotation>(parent, JetStubElementTypes.ANNOTATION)
             else parent
 
-    annotationIds.forEach {
+    annotationIds.forEach { annotation ->
-        annotationClassId ->
+        val (annotationClassId, target) = annotation
         val annotationEntryStubImpl = KotlinAnnotationEntryStubImpl(
                 entriesParent,
                 shortName = annotationClassId.getShortClassName().ref(),

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompilerBase.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.descriptors.ModuleParameters
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor
 import org.jetbrains.kotlin.name.ClassId
@@ -43,7 +44,7 @@ public abstract class DeserializerForDecompilerBase(
 
     protected abstract val classDataFinder: ClassDataFinder
 
-    protected abstract val annotationAndConstantLoader: AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>>
+    protected abstract val annotationAndConstantLoader: AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>, AnnotationWithTarget>
 
     protected val storageManager: StorageManager = LockBasedStorageManager.NO_LOCKS
 

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.serialization.js
 
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.*
@@ -25,7 +26,7 @@ import org.jetbrains.kotlin.types.JetType
 
 class KotlinJavascriptAnnotationAndConstantLoader(
         module: ModuleDescriptor
-) : AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>> {
+) : AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>, AnnotationWithTarget> {
     private val deserializer = AnnotationDeserializer(module)
 
     override fun loadClassAnnotations(
@@ -41,10 +42,9 @@ class KotlinJavascriptAnnotationAndConstantLoader(
             proto: ProtoBuf.Callable,
             nameResolver: NameResolver,
             kind: AnnotatedCallableKind
-    ): List<AnnotationDescriptor> {
+    ): List<AnnotationWithTarget> {
-        if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList()
         val annotations = proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty()
-        return annotations.map { proto -> deserializer.deserializeAnnotation(proto, nameResolver) }
+        return annotations.map { proto -> AnnotationWithTarget(deserializer.deserializeAnnotation(proto, nameResolver), null) }
     }
 
     override fun loadValueParameterAnnotations(