Extract duplicate logic between javascript and builtins serialization/deserialization

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<PackageFragmentDescriptor>, 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))
-        }
-    }
 }

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))
+        }
+    }
+}

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
+)

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

@@ -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<AnnotationDescriptor, ConstantValue<*>, AnnotationWithTarget> {
-    private val deserializer = AnnotationDeserializer(module)
-
-    override fun loadClassAnnotations(
-            classProto: ProtoBuf.Class,
-            nameResolver: NameResolver
-    ): List<AnnotationDescriptor> {
-        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<AnnotationWithTarget> {
-        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<AnnotationDescriptor> {
-        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<AnnotationDescriptor> = emptyList()
-
-    override fun loadTypeAnnotations(proto: ProtoBuf.Type, nameResolver: NameResolver): List<AnnotationDescriptor> {
-        return proto.getExtension(BuiltInsProtoBuf.typeAnnotation).orEmpty().map { deserializer.deserializeAnnotation(it, nameResolver) }
-    }
-
-    override fun loadTypeParameterAnnotations(proto: ProtoBuf.TypeParameter, nameResolver: NameResolver): List<AnnotationDescriptor> {
-        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)
-    }
-}

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,

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<ProtoBuf.Constructor, List<ProtoBuf.Annotation>>,
+        val classAnnotation: GeneratedExtension<ProtoBuf.Class, List<ProtoBuf.Annotation>>,
+        val functionAnnotation: GeneratedExtension<ProtoBuf.Function, List<ProtoBuf.Annotation>>,
+        val propertyAnnotation: GeneratedExtension<ProtoBuf.Property, List<ProtoBuf.Annotation>>,
+        val compileTimeValue: GeneratedExtension<ProtoBuf.Property, ProtoBuf.Annotation.Argument.Value>,
+        val parameterAnnotation: GeneratedExtension<ProtoBuf.ValueParameter, List<ProtoBuf.Annotation>>,
+        val typeAnnotation: GeneratedExtension<ProtoBuf.Type, List<ProtoBuf.Annotation>>,
+        val typeParameterAnnotation: GeneratedExtension<ProtoBuf.TypeParameter, List<ProtoBuf.Annotation>>
+)

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<AnnotationDescriptor, ConstantValue<*>, AnnotationWithTarget> {
     private val deserializer = AnnotationDeserializer(module)
 
@@ -34,7 +35,7 @@ class KotlinJavascriptAnnotationAndConstantLoader(
             classProto: ProtoBuf.Class,
             nameResolver: NameResolver
     ): List<AnnotationDescriptor> {
-        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<AnnotationWithTarget> {
         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<AnnotationDescriptor> {
-        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<AnnotationDescriptor> = emptyList()
 
     override fun loadTypeAnnotations(proto: ProtoBuf.Type, nameResolver: NameResolver): List<AnnotationDescriptor> {
-        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<AnnotationDescriptor> {
-        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)
     }
 }

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,

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
+)

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,