From 6164566cad655fe95aeb513ae69389576ec11aae Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Mon, 7 Dec 2015 19:06:28 +0300 Subject: [PATCH] Extract duplicate logic between javascript and builtins serialization/deserialization --- .../builtins/BuiltInsSerializerExtension.kt | 58 ++---------- .../serialization/SerializerExtensionBase.kt | 68 ++++++++++++++ .../builtins/BuiltInSerializerProtocol.kt | 26 ++++++ .../BuiltInsAnnotationAndConstantLoader.kt | 90 ------------------- .../builtInsPackageFragmentProvider.kt | 2 +- .../SerializerExtensionProtocol.kt | 30 +++++++ .../AnnotationAndConstantLoaderImpl.kt | 29 +++--- ...tlinJavaScriptDeserializerForDecompiler.kt | 2 +- .../js/KotlinJavascriptSerializerExtension.kt | 59 ++---------- ...kotlinJavascriptPackageFragmentProvider.kt | 2 +- 10 files changed, 155 insertions(+), 211 deletions(-) create mode 100644 compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionBase.kt create mode 100644 core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInSerializerProtocol.kt delete mode 100644 core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt create mode 100644 core/deserialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionProtocol.kt rename js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt => core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoaderImpl.kt (72%) diff --git a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt b/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt index 6021c0b8ee8..4dce8692d8b 100644 --- a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt +++ b/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt @@ -16,26 +16,17 @@ package org.jetbrains.kotlin.serialization.builtins -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.resolve.constants.NullValue +import org.jetbrains.kotlin.builtins.BuiltInSerializerProtocol +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter -import org.jetbrains.kotlin.serialization.* -import org.jetbrains.kotlin.types.KotlinType - -public class BuiltInsSerializerExtension : SerializerExtension() { - private val stringTable = StringTableImpl() - private val annotationSerializer = AnnotationSerializer(stringTable) - - override fun getStringTable(): StringTable = stringTable +import org.jetbrains.kotlin.serialization.DescriptorSerializer +import org.jetbrains.kotlin.serialization.KotlinSerializerExtensionBase +import org.jetbrains.kotlin.serialization.ProtoBuf +public class BuiltInsSerializerExtension : KotlinSerializerExtensionBase(BuiltInSerializerProtocol) { override fun shouldUseTypeTable(): Boolean = true - override fun serializeClass(descriptor: ClassDescriptor, proto: ProtoBuf.Class.Builder) { - for (annotation in descriptor.annotations) { - proto.addExtension(BuiltInsProtoBuf.classAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - } - override fun serializePackage(packageFragments: Collection, proto: ProtoBuf.Package.Builder) { if (packageFragments.isEmpty()) return @@ -49,39 +40,4 @@ public class BuiltInsSerializerExtension : SerializerExtension() { proto.setExtension(BuiltInsProtoBuf.packageFqName, stringTable.getPackageFqNameIndex(packageFragments.first().fqName)) } - - override fun serializeConstructor(descriptor: ConstructorDescriptor, proto: ProtoBuf.Constructor.Builder) { - for (annotation in descriptor.annotations) { - proto.addExtension(BuiltInsProtoBuf.constructorAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - } - - override fun serializeFunction(descriptor: FunctionDescriptor, proto: ProtoBuf.Function.Builder) { - for (annotation in descriptor.annotations) { - proto.addExtension(BuiltInsProtoBuf.functionAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - } - - override fun serializeProperty(descriptor: PropertyDescriptor, proto: ProtoBuf.Property.Builder) { - for (annotation in descriptor.annotations) { - proto.addExtension(BuiltInsProtoBuf.propertyAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - val compileTimeConstant = descriptor.compileTimeInitializer ?: return - if (compileTimeConstant !is NullValue) { - val valueProto = annotationSerializer.valueProto(compileTimeConstant) - proto.setExtension(BuiltInsProtoBuf.compileTimeValue, valueProto.build()) - } - } - - override fun serializeValueParameter(descriptor: ValueParameterDescriptor, proto: ProtoBuf.ValueParameter.Builder) { - for (annotation in descriptor.annotations) { - proto.addExtension(BuiltInsProtoBuf.parameterAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - } - - override fun serializeType(type: KotlinType, proto: ProtoBuf.Type.Builder) { - for (annotation in type.annotations) { - proto.addExtension(BuiltInsProtoBuf.typeAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - } } diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionBase.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionBase.kt new file mode 100644 index 00000000000..9767d051e64 --- /dev/null +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionBase.kt @@ -0,0 +1,68 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.serialization + +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.resolve.constants.NullValue +import org.jetbrains.kotlin.types.KotlinType + +public open class KotlinSerializerExtensionBase(private val protocol: SerializerExtensionProtocol) : SerializerExtension() { + private val stringTable = StringTableImpl() + private val annotationSerializer = AnnotationSerializer(stringTable) + + override fun getStringTable(): StringTableImpl = stringTable + + override fun serializeClass(descriptor: ClassDescriptor, proto: ProtoBuf.Class.Builder) { + for (annotation in descriptor.annotations) { + proto.addExtension(protocol.classAnnotation, annotationSerializer.serializeAnnotation(annotation)) + } + } + + override fun serializeConstructor(descriptor: ConstructorDescriptor, proto: ProtoBuf.Constructor.Builder) { + for (annotation in descriptor.annotations) { + proto.addExtension(protocol.constructorAnnotation, annotationSerializer.serializeAnnotation(annotation)) + } + } + + override fun serializeFunction(descriptor: FunctionDescriptor, proto: ProtoBuf.Function.Builder) { + for (annotation in descriptor.annotations) { + proto.addExtension(protocol.functionAnnotation, annotationSerializer.serializeAnnotation(annotation)) + } + } + + override fun serializeProperty(descriptor: PropertyDescriptor, proto: ProtoBuf.Property.Builder) { + for (annotation in descriptor.annotations) { + proto.addExtension(protocol.propertyAnnotation, annotationSerializer.serializeAnnotation(annotation)) + } + val constantInitializer = descriptor.compileTimeInitializer ?: return + if (constantInitializer !is NullValue) { + proto.setExtension(protocol.compileTimeValue, annotationSerializer.valueProto(constantInitializer).build()) + } + } + + override fun serializeValueParameter(descriptor: ValueParameterDescriptor, proto: ProtoBuf.ValueParameter.Builder) { + for (annotation in descriptor.annotations) { + proto.addExtension(protocol.parameterAnnotation, annotationSerializer.serializeAnnotation(annotation)) + } + } + + override fun serializeType(type: KotlinType, proto: ProtoBuf.Type.Builder) { + for (annotation in type.annotations) { + proto.addExtension(protocol.typeAnnotation, annotationSerializer.serializeAnnotation(annotation)) + } + } +} \ No newline at end of file diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInSerializerProtocol.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInSerializerProtocol.kt new file mode 100644 index 00000000000..147107d8d4c --- /dev/null +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInSerializerProtocol.kt @@ -0,0 +1,26 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.builtins + +import org.jetbrains.kotlin.serialization.SerializerExtensionProtocol +import org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf + +object BuiltInSerializerProtocol : SerializerExtensionProtocol( + BuiltInsProtoBuf.constructorAnnotation, BuiltInsProtoBuf.classAnnotation, BuiltInsProtoBuf.functionAnnotation, + BuiltInsProtoBuf.propertyAnnotation, BuiltInsProtoBuf.compileTimeValue, BuiltInsProtoBuf.parameterAnnotation, + BuiltInsProtoBuf.typeAnnotation, BuiltInsProtoBuf.typeParameterAnnotation +) diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt deleted file mode 100644 index 65206142699..00000000000 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt +++ /dev/null @@ -1,90 +0,0 @@ -/* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.builtins - -import com.google.protobuf.MessageLite -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 -import org.jetbrains.kotlin.serialization.deserialization.* -import org.jetbrains.kotlin.types.KotlinType - -class BuiltInsAnnotationAndConstantLoader( - module: ModuleDescriptor -) : AnnotationAndConstantLoader, AnnotationWithTarget> { - private val deserializer = AnnotationDeserializer(module) - - override fun loadClassAnnotations( - classProto: ProtoBuf.Class, - nameResolver: NameResolver - ): List { - val annotations = classProto.getExtension(BuiltInsProtoBuf.classAnnotation).orEmpty() - return annotations.map { proto -> deserializer.deserializeAnnotation(proto, nameResolver) } - } - - override fun loadCallableAnnotations( - container: ProtoContainer, - proto: MessageLite, - kind: AnnotatedCallableKind - ): List { - val annotations = when (proto) { - is ProtoBuf.Constructor -> proto.getExtension(BuiltInsProtoBuf.constructorAnnotation) - is ProtoBuf.Function -> proto.getExtension(BuiltInsProtoBuf.functionAnnotation) - is ProtoBuf.Property -> proto.getExtension(BuiltInsProtoBuf.propertyAnnotation) - else -> error("Unknown message: $proto") - }.orEmpty() - return annotations.map { proto -> AnnotationWithTarget(deserializer.deserializeAnnotation(proto, container.nameResolver), null) } - } - - override fun loadValueParameterAnnotations( - container: ProtoContainer, - message: MessageLite, - kind: AnnotatedCallableKind, - parameterIndex: Int, - proto: ProtoBuf.ValueParameter - ): List { - val annotations = proto.getExtension(BuiltInsProtoBuf.parameterAnnotation).orEmpty() - return annotations.map { proto -> deserializer.deserializeAnnotation(proto, container.nameResolver) } - } - - override fun loadExtensionReceiverParameterAnnotations( - container: ProtoContainer, - message: MessageLite, - kind: AnnotatedCallableKind - ): List = emptyList() - - override fun loadTypeAnnotations(proto: ProtoBuf.Type, nameResolver: NameResolver): List { - return proto.getExtension(BuiltInsProtoBuf.typeAnnotation).orEmpty().map { deserializer.deserializeAnnotation(it, nameResolver) } - } - - override fun loadTypeParameterAnnotations(proto: ProtoBuf.TypeParameter, nameResolver: NameResolver): List { - return proto.getExtension(BuiltInsProtoBuf.typeParameterAnnotation).orEmpty().map { deserializer.deserializeAnnotation(it, nameResolver) } - } - - override fun loadPropertyConstant( - container: ProtoContainer, - proto: ProtoBuf.Property, - expectedType: KotlinType - ): ConstantValue<*>? { - if (!proto.hasExtension(BuiltInsProtoBuf.compileTimeValue)) return null - val value = proto.getExtension(BuiltInsProtoBuf.compileTimeValue) - return deserializer.resolveValue(expectedType, value, container.nameResolver) - } -} diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/builtInsPackageFragmentProvider.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/builtInsPackageFragmentProvider.kt index 77e5f0c8cd9..8fa7821cc02 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/builtInsPackageFragmentProvider.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/builtInsPackageFragmentProvider.kt @@ -44,7 +44,7 @@ public fun createBuiltInPackageFragmentProvider( storageManager, module, ResourceLoadingClassDataFinder(provider, BuiltInsSerializedResourcePaths, loadResource), - BuiltInsAnnotationAndConstantLoader(module), + AnnotationAndConstantLoaderImpl(module, BuiltInSerializerProtocol), provider, localClassResolver, ErrorReporter.DO_NOTHING, diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionProtocol.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionProtocol.kt new file mode 100644 index 00000000000..8b4e0b9b988 --- /dev/null +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionProtocol.kt @@ -0,0 +1,30 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.serialization; + +import com.google.protobuf.GeneratedMessageLite.GeneratedExtension + +open class SerializerExtensionProtocol( + val constructorAnnotation: GeneratedExtension>, + val classAnnotation: GeneratedExtension>, + val functionAnnotation: GeneratedExtension>, + val propertyAnnotation: GeneratedExtension>, + val compileTimeValue: GeneratedExtension, + val parameterAnnotation: GeneratedExtension>, + val typeAnnotation: GeneratedExtension>, + val typeParameterAnnotation: GeneratedExtension> +) diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoaderImpl.kt similarity index 72% rename from js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt rename to core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoaderImpl.kt index b05bd1381eb..b203de15bc5 100644 --- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoaderImpl.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.kotlin.serialization.js +package org.jetbrains.kotlin.serialization.deserialization import com.google.protobuf.MessageLite import org.jetbrains.kotlin.descriptors.ModuleDescriptor @@ -22,11 +22,12 @@ 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.* +import org.jetbrains.kotlin.serialization.SerializerExtensionProtocol import org.jetbrains.kotlin.types.KotlinType -class KotlinJavascriptAnnotationAndConstantLoader( - module: ModuleDescriptor +class AnnotationAndConstantLoaderImpl( + module: ModuleDescriptor, + private val protocol: SerializerExtensionProtocol ) : AnnotationAndConstantLoader, AnnotationWithTarget> { private val deserializer = AnnotationDeserializer(module) @@ -34,7 +35,7 @@ class KotlinJavascriptAnnotationAndConstantLoader( classProto: ProtoBuf.Class, nameResolver: NameResolver ): List { - val annotations = classProto.getExtension(JsProtoBuf.classAnnotation).orEmpty() + val annotations = classProto.getExtension(protocol.classAnnotation).orEmpty() return annotations.map { proto -> deserializer.deserializeAnnotation(proto, nameResolver) } } @@ -44,9 +45,9 @@ class KotlinJavascriptAnnotationAndConstantLoader( kind: AnnotatedCallableKind ): List { val annotations = when (proto) { - is ProtoBuf.Constructor -> proto.getExtension(JsProtoBuf.constructorAnnotation) - is ProtoBuf.Function -> proto.getExtension(JsProtoBuf.functionAnnotation) - is ProtoBuf.Property -> proto.getExtension(JsProtoBuf.propertyAnnotation) + is ProtoBuf.Constructor -> proto.getExtension(protocol.constructorAnnotation) + is ProtoBuf.Function -> proto.getExtension(protocol.functionAnnotation) + is ProtoBuf.Property -> proto.getExtension(protocol.propertyAnnotation) else -> error("Unknown message: $proto") }.orEmpty() return annotations.map { proto -> AnnotationWithTarget(deserializer.deserializeAnnotation(proto, container.nameResolver), null) } @@ -59,7 +60,7 @@ class KotlinJavascriptAnnotationAndConstantLoader( parameterIndex: Int, proto: ProtoBuf.ValueParameter ): List { - val annotations = proto.getExtension(JsProtoBuf.parameterAnnotation).orEmpty() + val annotations = proto.getExtension(protocol.parameterAnnotation).orEmpty() return annotations.map { proto -> deserializer.deserializeAnnotation(proto, container.nameResolver) } } @@ -70,13 +71,11 @@ class KotlinJavascriptAnnotationAndConstantLoader( ): List = emptyList() override fun loadTypeAnnotations(proto: ProtoBuf.Type, nameResolver: NameResolver): List { - val annotations = proto.getExtension(JsProtoBuf.typeAnnotation).orEmpty() - return annotations.map { proto -> deserializer.deserializeAnnotation(proto, nameResolver) } + return proto.getExtension(protocol.typeAnnotation).orEmpty().map { deserializer.deserializeAnnotation(it, nameResolver) } } override fun loadTypeParameterAnnotations(proto: ProtoBuf.TypeParameter, nameResolver: NameResolver): List { - val annotations = proto.getExtension(JsProtoBuf.typeParameterAnnotation).orEmpty() - return annotations.map { proto -> deserializer.deserializeAnnotation(proto, nameResolver) } + return proto.getExtension(protocol.typeParameterAnnotation).orEmpty().map { deserializer.deserializeAnnotation(it, nameResolver) } } override fun loadPropertyConstant( @@ -84,8 +83,8 @@ class KotlinJavascriptAnnotationAndConstantLoader( proto: ProtoBuf.Property, expectedType: KotlinType ): ConstantValue<*>? { - if (!proto.hasExtension(JsProtoBuf.compileTimeValue)) return null - val value = proto.getExtension(JsProtoBuf.compileTimeValue) + if (!proto.hasExtension(protocol.compileTimeValue)) return null + val value = proto.getExtension(protocol.compileTimeValue) return deserializer.resolveValue(expectedType, value, container.nameResolver) } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/js/KotlinJavaScriptDeserializerForDecompiler.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/js/KotlinJavaScriptDeserializerForDecompiler.kt index dee2bb75bb0..1eedf5cddfd 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/js/KotlinJavaScriptDeserializerForDecompiler.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/js/KotlinJavaScriptDeserializerForDecompiler.kt @@ -52,7 +52,7 @@ public class KotlinJavaScriptDeserializerForDecompiler( private val classDataFinder = DirectoryBasedKotlinJavaScriptDataFinder(metaFileFinder, LOG) - private val annotationAndConstantLoader = KotlinJavascriptAnnotationAndConstantLoader(moduleDescriptor) + private val annotationAndConstantLoader = AnnotationAndConstantLoaderImpl(moduleDescriptor, JsSerializerProtocol) override val deserializationComponents = DeserializationComponents( storageManager, moduleDescriptor, classDataFinder, annotationAndConstantLoader, packageFragmentProvider, diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt index 4c3c457e112..0d639fbe576 100644 --- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt +++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt @@ -16,57 +16,12 @@ package org.jetbrains.kotlin.serialization.js -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.resolve.constants.NullValue -import org.jetbrains.kotlin.serialization.AnnotationSerializer -import org.jetbrains.kotlin.serialization.ProtoBuf -import org.jetbrains.kotlin.serialization.SerializerExtension -import org.jetbrains.kotlin.serialization.StringTableImpl -import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.serialization.KotlinSerializerExtensionBase +import org.jetbrains.kotlin.serialization.SerializerExtensionProtocol -public class KotlinJavascriptSerializerExtension : SerializerExtension() { - private val stringTable = StringTableImpl() - private val annotationSerializer = AnnotationSerializer(stringTable) +public class KotlinJavascriptSerializerExtension : KotlinSerializerExtensionBase(JsSerializerProtocol) - override fun getStringTable() = stringTable - - override fun serializeClass(descriptor: ClassDescriptor, proto: ProtoBuf.Class.Builder) { - for (annotation in descriptor.annotations) { - proto.addExtension(JsProtoBuf.classAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - } - - override fun serializeConstructor(descriptor: ConstructorDescriptor, proto: ProtoBuf.Constructor.Builder) { - for (annotation in descriptor.annotations) { - proto.addExtension(JsProtoBuf.constructorAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - } - - override fun serializeFunction(descriptor: FunctionDescriptor, proto: ProtoBuf.Function.Builder) { - for (annotation in descriptor.annotations) { - proto.addExtension(JsProtoBuf.functionAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - } - - override fun serializeProperty(descriptor: PropertyDescriptor, proto: ProtoBuf.Property.Builder) { - for (annotation in descriptor.annotations) { - proto.addExtension(JsProtoBuf.propertyAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - val constantInitializer = descriptor.compileTimeInitializer ?: return - if (constantInitializer !is NullValue) { - proto.setExtension(JsProtoBuf.compileTimeValue, annotationSerializer.valueProto(constantInitializer).build()) - } - } - - override fun serializeValueParameter(descriptor: ValueParameterDescriptor, proto: ProtoBuf.ValueParameter.Builder) { - for (annotation in descriptor.annotations) { - proto.addExtension(JsProtoBuf.parameterAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - } - - override fun serializeType(type: KotlinType, proto: ProtoBuf.Type.Builder) { - for (annotation in type.annotations) { - proto.addExtension(JsProtoBuf.typeAnnotation, annotationSerializer.serializeAnnotation(annotation)) - } - } -} +object JsSerializerProtocol : SerializerExtensionProtocol( + JsProtoBuf.constructorAnnotation, JsProtoBuf.classAnnotation, JsProtoBuf.functionAnnotation, JsProtoBuf.propertyAnnotation, + JsProtoBuf.compileTimeValue, JsProtoBuf.parameterAnnotation, JsProtoBuf.typeAnnotation, JsProtoBuf.typeParameterAnnotation +) \ No newline at end of file diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/kotlinJavascriptPackageFragmentProvider.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/kotlinJavascriptPackageFragmentProvider.kt index 3791f67275f..9aac688673f 100644 --- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/kotlinJavascriptPackageFragmentProvider.kt +++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/kotlinJavascriptPackageFragmentProvider.kt @@ -42,7 +42,7 @@ public fun createKotlinJavascriptPackageFragmentProvider( storageManager, module, ResourceLoadingClassDataFinder(provider, KotlinJavascriptSerializedResourcePaths, loadResource), - KotlinJavascriptAnnotationAndConstantLoader(module), + AnnotationAndConstantLoaderImpl(module, JsSerializerProtocol), provider, localClassResolver, ErrorReporter.DO_NOTHING,