Use a single AnnotatedCallableKind enum item for property

2015-08-27 18:15:14 +03:00
parent 97e4c097ba
commit e7703df0b6
14 changed files with 130 additions and 118 deletions
@@ -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(),
@@ -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
-import org.jetbrains.kotlin.serialization.deserialization.AnnotatedCallableKind.PROPERTY_FIELD
-
-public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C : Any>(
+public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C : Any, T : 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)
-                && annotatedCallableKind != AnnotatedCallableKind.PROPERTY_SYNTHETIC_FUNCTION) {
+        if (classKind == ProtoBuf.Class.Kind.CLASS_OBJECT && isStaticFieldInOuter(proto) && seekForStaticFieldInOuter) {
            // 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 &&
-                 (annotatedCallableKind == PROPERTY_SYNTHETIC_FUNCTION || annotatedCallableKind == PROPERTY_FIELD)) {
+        else if (classKind == ProtoBuf.Class.Kind.TRAIT && (annotatedCallableKind == AnnotatedCallableKind.PROPERTY)) {
            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>(
-            public val memberAnnotations: Map<MemberSignature, List<A>>,
-            public val propertyConstants: Map<MemberSignature, C>
-    )
-}
-
-private fun getCallableSignature(
-        proto: ProtoBuf.Callable,
-        nameResolver: NameResolver,
-        kind: AnnotatedCallableKind
-): MemberSignature? {
-    val deserializer = SignatureDeserializer(nameResolver)
-
-    fun getPropertySignature(handleField: Boolean = false, handleSynthetic: Boolean = false): MemberSignature? {
+    private fun getPropertySignature(
+            proto: ProtoBuf.Callable,
+            nameResolver: NameResolver,
+            field: Boolean = false,
+            synthetic: Boolean = false
+    ): MemberSignature? {
        if (!proto.hasExtension(propertySignature)) return null

        val propertySignature = proto.getExtension(propertySignature)
+        val deserializer = SignatureDeserializer(nameResolver)

-        if (handleField && propertySignature.hasField()) {
-            val field = propertySignature.getField()
-            val type = deserializer.typeDescriptor(field.getType())
-            val name = nameResolver.getName(field.getName())
+        if (field && propertySignature.hasField()) {
+            val field = propertySignature.field
+            val type = deserializer.typeDescriptor(field.type)
+            val name = nameResolver.getName(field.name)
            return MemberSignature.fromFieldNameAndDesc(name, type)
        }
-        else if (handleSynthetic && propertySignature.hasSyntheticMethod()) {
-            return deserializer.methodSignature(propertySignature.getSyntheticMethod())
+        else if (synthetic && propertySignature.hasSyntheticMethod()) {
+            return deserializer.methodSignature(propertySignature.syntheticMethod)
        }

        return null
    }

-    when (kind) {
-        AnnotatedCallableKind.FUNCTION -> if (proto.hasExtension(methodSignature)) {
-            return deserializer.methodSignature(proto.getExtension(methodSignature))
+    private fun getCallableSignature(
+            proto: ProtoBuf.Callable,
+            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 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
    }
-    return null
-}
+
+    private class Storage<A, C>(
+            public val memberAnnotations: Map<MemberSignature, List<A>>,
+            public val propertyConstants: Map<MemberSignature, C>
+    )
+}
@@ -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,
@@ -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> {
-        if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList()
+    ): List<AnnotationWithTarget> {
        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(
@@ -19,8 +19,6 @@ package org.jetbrains.kotlin.serialization.deserialization;
 public enum AnnotatedCallableKind {
    FUNCTION,
    PROPERTY,
-    PROPERTY_SYNTHETIC_FUNCTION,
-    PROPERTY_FIELD,
    PROPERTY_GETTER,
    PROPERTY_SETTER
 }
@@ -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,
@@ -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) }
-    }
 }
@@ -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,
@@ -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> {
-        if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList()
-        return proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty().map { nameResolver.getClassId(it.getId()) }
+    ): List<ClassIdWithTarget> {
+        return proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty().map { ClassIdWithTarget(nameResolver.getClassId(it.id), null) }
    }

    override fun loadValueParameterAnnotations(
@@ -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) {
-            createAnnotationStubs(AnnotatedCallableKind.PROPERTY_SYNTHETIC_FUNCTION)
-            createAnnotationStubs(AnnotatedCallableKind.PROPERTY_FIELD)
-        }
-        else {
-            createAnnotationStubs(kind)
-        }
+        val annotationIds = c.components.annotationLoader.loadCallableAnnotations(protoContainer, callableProto, c.nameResolver, kind)
+        createTargetedAnnotationStubs(annotationIds, modifierListStubImpl, needWrappingAnnotationEntries = isPrimaryConstructor)
    }

    private fun doCreateCallableStub(): StubElement<out PsiElement> {
@@ -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) }
 }
@@ -171,11 +171,14 @@ fun createModifierListStub(
    )
 }

-fun createAnnotationStubs(
-        annotationIds: List<ClassId>,
+fun createAnnotationStubs(annotationIds: List<ClassId>, parent: KotlinStubBaseImpl<*>, needWrappingAnnotationEntries: Boolean = false) {
+    return createTargetedAnnotationStubs(annotationIds.map { ClassIdWithTarget(it, null) }, parent, needWrappingAnnotationEntries)
+}
+
+fun createTargetedAnnotationStubs(
+        annotationIds: List<ClassIdWithTarget>,
        parent: KotlinStubBaseImpl<*>,
-        needWrappingAnnotationEntries: Boolean = false,
-        target: AnnotationUseSiteTarget? = null
+        needWrappingAnnotationEntries: Boolean = false
 ) {
    if (annotationIds.isEmpty()) return

@@ -183,8 +186,8 @@ fun createAnnotationStubs(
            if (needWrappingAnnotationEntries) KotlinPlaceHolderStubImpl<JetAnnotation>(parent, JetStubElementTypes.ANNOTATION)
            else parent

-    annotationIds.forEach {
-        annotationClassId ->
+    annotationIds.forEach { annotation ->
+        val (annotationClassId, target) = annotation
        val annotationEntryStubImpl = KotlinAnnotationEntryStubImpl(
                entriesParent,
                shortName = annotationClassId.getShortClassName().ref(),
@@ -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

@@ -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> {
-        if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList()
+    ): List<AnnotationWithTarget> {
        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(