Extract duplicate logic between javascript and builtins serialization/deserialization

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/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.builtins
+package org.jetbrains.kotlin.serialization.deserialization
 
 import com.google.protobuf.MessageLite
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -22,12 +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.builtins.BuiltInsProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.*
+import org.jetbrains.kotlin.serialization.SerializerExtensionProtocol
 import org.jetbrains.kotlin.types.KotlinType
 
-class BuiltInsAnnotationAndConstantLoader(
-        module: ModuleDescriptor
+class AnnotationAndConstantLoaderImpl(
+        module: ModuleDescriptor,
+        private val protocol: SerializerExtensionProtocol
 ) : AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>, AnnotationWithTarget> {
     private val deserializer = AnnotationDeserializer(module)
 
@@ -35,7 +35,7 @@ class BuiltInsAnnotationAndConstantLoader(
             classProto: ProtoBuf.Class,
             nameResolver: NameResolver
     ): List<AnnotationDescriptor> {
-        val annotations = classProto.getExtension(BuiltInsProtoBuf.classAnnotation).orEmpty()
+        val annotations = classProto.getExtension(protocol.classAnnotation).orEmpty()
         return annotations.map { proto -> deserializer.deserializeAnnotation(proto, nameResolver) }
     }
 
@@ -45,9 +45,9 @@ class BuiltInsAnnotationAndConstantLoader(
             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)
+            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) }
@@ -60,7 +60,7 @@ class BuiltInsAnnotationAndConstantLoader(
             parameterIndex: Int,
             proto: ProtoBuf.ValueParameter
     ): List<AnnotationDescriptor> {
-        val annotations = proto.getExtension(BuiltInsProtoBuf.parameterAnnotation).orEmpty()
+        val annotations = proto.getExtension(protocol.parameterAnnotation).orEmpty()
         return annotations.map { proto -> deserializer.deserializeAnnotation(proto, container.nameResolver) }
     }
 
@@ -71,11 +71,11 @@ class BuiltInsAnnotationAndConstantLoader(
     ): List<AnnotationDescriptor> = emptyList()
 
     override fun loadTypeAnnotations(proto: ProtoBuf.Type, nameResolver: NameResolver): List<AnnotationDescriptor> {
-        return proto.getExtension(BuiltInsProtoBuf.typeAnnotation).orEmpty().map { deserializer.deserializeAnnotation(it, nameResolver) }
+        return proto.getExtension(protocol.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) }
+        return proto.getExtension(protocol.typeParameterAnnotation).orEmpty().map { deserializer.deserializeAnnotation(it, nameResolver) }
     }
 
     override fun loadPropertyConstant(
@@ -83,8 +83,8 @@ class BuiltInsAnnotationAndConstantLoader(
             proto: ProtoBuf.Property,
             expectedType: KotlinType
     ): ConstantValue<*>? {
-        if (!proto.hasExtension(BuiltInsProtoBuf.compileTimeValue)) return null
-        val value = proto.getExtension(BuiltInsProtoBuf.compileTimeValue)
+        if (!proto.hasExtension(protocol.compileTimeValue)) return null
+        val value = proto.getExtension(protocol.compileTimeValue)
         return deserializer.resolveValue(expectedType, value, container.nameResolver)
     }
 }