diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java index df632925693..b272cf65632 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java @@ -140,7 +140,7 @@ public class JvmSerializerExtension extends SerializerExtension { fieldType = field.first; fieldName = field.second; isStaticInOuter = bindings.get(STATIC_FIELD_IN_OUTER_CLASS, property); - syntheticMethod = null; + syntheticMethod = bindings.get(SYNTHETIC_METHOD_FOR_PROPERTY, property); } else { fieldType = null; 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 a51da420ce0..8bd3dad0e4d 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,6 +34,9 @@ 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( storageManager: StorageManager, private val kotlinClassFinder: KotlinClassFinder, @@ -182,11 +185,14 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader if (proto.hasExtension(methodSignature)) { return deserializer.methodSignature(proto.getExtension(methodSignature)) @@ -292,19 +317,9 @@ private fun getCallableSignature( AnnotatedCallableKind.PROPERTY_SETTER -> if (proto.hasExtension(propertySignature)) { return deserializer.methodSignature(proto.getExtension(propertySignature).getSetter()) } - AnnotatedCallableKind.PROPERTY -> if (proto.hasExtension(propertySignature)) { - val propertySignature = proto.getExtension(propertySignature) - - if (propertySignature.hasField()) { - val field = propertySignature.getField() - val type = deserializer.typeDescriptor(field.getType()) - val name = nameResolver.getName(field.getName()) - return MemberSignature.fromFieldNameAndDesc(name, type) - } - else if (propertySignature.hasSyntheticMethod()) { - return deserializer.methodSignature(propertySignature.getSyntheticMethod()) - } - } + AnnotatedCallableKind.PROPERTY -> return getPropertySignature(true, true) + AnnotatedCallableKind.PROPERTY_FIELD -> return getPropertySignature(handleField = true) + AnnotatedCallableKind.PROPERTY_SYNTHETIC_FUNCTION -> return getPropertySignature(handleSynthetic = true) } return null } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt index f91765f4c8b..1e9a4d6ce01 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt @@ -43,6 +43,7 @@ class BuiltInsAnnotationAndConstantLoader( nameResolver: NameResolver, kind: AnnotatedCallableKind ): List { + if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList() val annotations = proto.getExtension(BuiltInsProtoBuf.callableAnnotation).orEmpty() return annotations.map { proto -> deserializer.deserializeAnnotation(proto, nameResolver) } } 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 0d41d3eb619..de82146629f 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotatedCallableKind.java +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotatedCallableKind.java @@ -19,6 +19,8 @@ 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/MemberDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt index a9b86f6df07..fed8a825edf 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt @@ -17,6 +17,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.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget import org.jetbrains.kotlin.descriptors.annotations.Annotations @@ -31,7 +32,6 @@ import org.jetbrains.kotlin.serialization.ProtoBuf.Callable.CallableKind.VAL import org.jetbrains.kotlin.serialization.ProtoBuf.Callable.CallableKind.VAR import org.jetbrains.kotlin.serialization.deserialization.descriptors.* import org.jetbrains.kotlin.utils.toReadOnlyList -import org.jetbrains.kotlin.utils.sure public class MemberDeserializer(private val c: DeserializationContext) { public fun loadCallable(proto: Callable): CallableMemberDescriptor { @@ -48,7 +48,7 @@ public class MemberDeserializer(private val c: DeserializationContext) { val property = DeserializedPropertyDescriptor( c.containingDeclaration, null, - getAnnotations(proto, flags, AnnotatedCallableKind.PROPERTY), + getPropertyAnnotations(proto), modality(Flags.MODALITY.get(flags)), visibility(Flags.VISIBILITY.get(flags)), Flags.CALLABLE_KIND.get(flags) == Callable.CallableKind.VAR, @@ -185,22 +185,36 @@ public class MemberDeserializer(private val c: DeserializationContext) { } } + 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, receiverTargetedKind: AnnotatedCallableKind = kind ): Annotations { return DeserializedAnnotationsWithPossibleTargets(c.storageManager) { - val annotations = arrayListOf() - val container = c.containingDeclaration.asProtoContainer() - if (proto.hasReceiverType()) { - annotations += c.components.annotationAndConstantLoader + val container = c.containingDeclaration.asProtoContainer() + c.components.annotationAndConstantLoader .loadExtensionReceiverParameterAnnotations(container, proto, c.nameResolver, receiverTargetedKind) .map { AnnotationWithTarget(it, AnnotationUseSiteTarget.RECEIVER) } - } - - annotations + } else emptyList() } } @@ -227,9 +241,6 @@ public class MemberDeserializer(private val c: DeserializationContext) { kind: AnnotatedCallableKind, valueParameter: Callable.ValueParameter ): Annotations { - if (!Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags())) { - return Annotations.EMPTY - } return DeserializedAnnotations(c.storageManager) { c.components.annotationAndConstantLoader.loadValueParameterAnnotations(container, callable, c.nameResolver, kind, valueParameter) } @@ -240,4 +251,9 @@ 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/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/AnnotationLoaderForKotlinJavaScriptStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/AnnotationLoaderForKotlinJavaScriptStubBuilder.kt index 153a371511f..83f94aeb3b2 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 @@ -37,8 +37,10 @@ public class AnnotationLoaderForKotlinJavaScriptStubBuilder() : AnnotationAndCon proto: ProtoBuf.Callable, nameResolver: NameResolver, kind: AnnotatedCallableKind - ): List = - proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty().map { nameResolver.getClassId(it.getId()) } + ): List { + if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList() + return proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty().map { nameResolver.getClassId(it.getId()) } + } override fun loadValueParameterAnnotations( container: ProtoContainer, 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 5ab9eba382c..83f9700093e 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 @@ -42,6 +42,7 @@ class KotlinJavascriptAnnotationAndConstantLoader( nameResolver: NameResolver, kind: AnnotatedCallableKind ): List { + if (kind == AnnotatedCallableKind.PROPERTY_FIELD) return emptyList() val annotations = proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty() return annotations.map { proto -> deserializer.deserializeAnnotation(proto, nameResolver) } }