diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java index 983646a4731..698ddb2c3ce 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java +++ b/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(), diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt index 8bd3dad0e4d..5c5207d89fc 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt +++ b/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 -import org.jetbrains.kotlin.serialization.deserialization.AnnotatedCallableKind.PROPERTY_FIELD - -public abstract class AbstractBinaryClassAnnotationAndConstantLoader( +public abstract class AbstractBinaryClassAnnotationAndConstantLoader( storageManager: StorageManager, private val kotlinClassFinder: KotlinClassFinder, private val errorReporter: ErrorReporter -) : AnnotationAndConstantLoader { +) : AnnotationAndConstantLoader { private val storage = storageManager.createMemoizedFunction> { kotlinClass -> loadAnnotationsAndInitializers(kotlinClass) @@ -96,19 +93,38 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader { + ): List { + 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, fieldAnnotations: List): List + + protected abstract fun transformAnnotations(annotations: List): List + private fun findClassAndLoadMemberAnnotations( container: ProtoContainer, proto: ProtoBuf.Callable, nameResolver: NameResolver, kind: AnnotatedCallableKind, - signature: MemberSignature + signature: MemberSignature, + seekForStaticFieldInOuter: Boolean = true ): List { - 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( - public val memberAnnotations: Map>, - public val propertyConstants: Map - ) -} - -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( + public val memberAnnotations: Map>, + public val propertyConstants: Map + ) +} \ No newline at end of file diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt index 9e67dd01fab..260ce414277 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt +++ b/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>( +) : AbstractBinaryClassAnnotationAndConstantLoader, 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, + fieldAnnotations: List + ): List { + return propertyAnnotations.map { AnnotationWithTarget(it, null) } + + fieldAnnotations.map { AnnotationWithTarget(it, AnnotationUseSiteTarget.FIELD) } + } + + override fun transformAnnotations(annotations: List): List { + return annotations.map { AnnotationWithTarget(it, null) } + } + override fun loadAnnotation( annotationClassId: ClassId, source: SourceElement, diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt index 1e9a4d6ce01..0a92aa51e8a 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt +++ b/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> { +) : AnnotationAndConstantLoader, AnnotationWithTarget> { private val deserializer = AnnotationDeserializer(module) override fun loadClassAnnotations( @@ -42,10 +43,9 @@ class BuiltInsAnnotationAndConstantLoader( proto: ProtoBuf.Callable, nameResolver: NameResolver, kind: AnnotatedCallableKind - ): List { - if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList() + ): List { 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( diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotatedCallableKind.java b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotatedCallableKind.java index de82146629f..0d41d3eb619 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotatedCallableKind.java +++ b/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 } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java index d7720c80b17..5a435297950 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java +++ b/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 { +public interface AnnotationAndConstantLoader { @NotNull List loadClassAnnotations( @NotNull ProtoBuf.Class classProto, @@ -31,7 +31,7 @@ public interface AnnotationAndConstantLoader { ); @NotNull - List loadCallableAnnotations( + List loadCallableAnnotations( @NotNull ProtoContainer container, @NotNull ProtoBuf.Callable proto, @NotNull NameResolver nameResolver, diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt index 378fc3c32a0..fcb1b6d49f4 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt +++ b/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() - 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) } - } } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/context.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/context.kt index c18e9616bad..6f1f6007e38 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/context.kt +++ b/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>, + public val annotationAndConstantLoader: AnnotationAndConstantLoader, AnnotationWithTarget>, public val packageFragmentProvider: PackageFragmentProvider, public val localClassResolver: LocalClassResolver, public val flexibleTypeCapabilitiesDeserializer: FlexibleTypeCapabilitiesDeserializer, diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/AnnotationLoaderForKotlinJavaScriptStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/AnnotationLoaderForKotlinJavaScriptStubBuilder.kt index 83f94aeb3b2..51ff14159f2 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/AnnotationLoaderForKotlinJavaScriptStubBuilder.kt +++ b/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 { +public class AnnotationLoaderForKotlinJavaScriptStubBuilder() : AnnotationAndConstantLoader { override fun loadClassAnnotations( classProto: ProtoBuf.Class, nameResolver: NameResolver @@ -37,9 +38,8 @@ public class AnnotationLoaderForKotlinJavaScriptStubBuilder() : AnnotationAndCon proto: ProtoBuf.Callable, nameResolver: NameResolver, kind: AnnotatedCallableKind - ): List { - if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList() - return proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty().map { nameResolver.getClassId(it.getId()) } + ): List { + return proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty().map { ClassIdWithTarget(nameResolver.getClassId(it.id), null) } } override fun loadValueParameterAnnotations( diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt index b412aa09435..68a9b7cf3dd 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt +++ b/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) { - 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 { diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderContext.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderContext.kt index b6f4a28a080..f58e198b8b3 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderContext.kt +++ b/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 + val annotationLoader: AnnotationAndConstantLoader ) { fun createContext( nameResolver: NameResolver, @@ -92,7 +95,7 @@ private fun ClsStubBuilderContext.child(nameResolver: NameResolver): ClsStubBuil class AnnotationLoaderForStubBuilder( kotlinClassFinder: KotlinClassFinder, errorReporter: ErrorReporter -) : AbstractBinaryClassAnnotationAndConstantLoader( +) : AbstractBinaryClassAnnotationAndConstantLoader( LockBasedStorageManager.NO_LOCKS, kotlinClassFinder, errorReporter) { override fun loadClassAnnotations( @@ -116,4 +119,11 @@ class AnnotationLoaderForStubBuilder( result.add(annotationClassId) return null } + + override fun loadPropertyAnnotations(propertyAnnotations: List, fieldAnnotations: List): List { + return propertyAnnotations.map { ClassIdWithTarget(it, null) } + + fieldAnnotations.map { ClassIdWithTarget(it, AnnotationUseSiteTarget.FIELD) } + } + + override fun transformAnnotations(annotations: List) = annotations.map { ClassIdWithTarget(it, null) } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt index 7babe893efb..fc0c4760d92 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt @@ -171,11 +171,14 @@ fun createModifierListStub( ) } -fun createAnnotationStubs( - annotationIds: List, +fun createAnnotationStubs(annotationIds: List, parent: KotlinStubBaseImpl<*>, needWrappingAnnotationEntries: Boolean = false) { + return createTargetedAnnotationStubs(annotationIds.map { ClassIdWithTarget(it, null) }, parent, needWrappingAnnotationEntries) +} + +fun createTargetedAnnotationStubs( + annotationIds: List, parent: KotlinStubBaseImpl<*>, - needWrappingAnnotationEntries: Boolean = false, - target: AnnotationUseSiteTarget? = null + needWrappingAnnotationEntries: Boolean = false ) { if (annotationIds.isEmpty()) return @@ -183,8 +186,8 @@ fun createAnnotationStubs( if (needWrappingAnnotationEntries) KotlinPlaceHolderStubImpl(parent, JetStubElementTypes.ANNOTATION) else parent - annotationIds.forEach { - annotationClassId -> + annotationIds.forEach { annotation -> + val (annotationClassId, target) = annotation val annotationEntryStubImpl = KotlinAnnotationEntryStubImpl( entriesParent, shortName = annotationClassId.getShortClassName().ref(), diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompilerBase.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompilerBase.kt index badad22cf71..1644a148b80 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompilerBase.kt +++ b/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> + protected abstract val annotationAndConstantLoader: AnnotationAndConstantLoader, AnnotationWithTarget> protected val storageManager: StorageManager = LockBasedStorageManager.NO_LOCKS diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt index 83f9700093e..13618cba014 100644 --- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt +++ b/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> { +) : AnnotationAndConstantLoader, AnnotationWithTarget> { private val deserializer = AnnotationDeserializer(module) override fun loadClassAnnotations( @@ -41,10 +42,9 @@ class KotlinJavascriptAnnotationAndConstantLoader( proto: ProtoBuf.Callable, nameResolver: NameResolver, kind: AnnotatedCallableKind - ): List { - if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList() + ): List { 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(