Get rid of SerializationUtil, move methods to DescriptorSerializer

compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java

@@ -41,9 +41,6 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.serialization.DescriptorSerializer;
 import org.jetbrains.kotlin.serialization.ProtoBuf;
-import org.jetbrains.kotlin.serialization.SerializationUtil;
-import org.jetbrains.kotlin.serialization.StringTable;
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver;
 import org.jetbrains.kotlin.serialization.jvm.BitEncoding;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
@@ -233,13 +230,10 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
 
         ProtoBuf.Callable callableProto = serializer.callableProto(funDescriptor).build();
 
-        StringTable strings = serializer.getStringTable();
-        NameResolver nameResolver = new NameResolver(strings.serializeSimpleNames(), strings.serializeQualifiedNames());
-
         AnnotationVisitor av = v.getVisitor().visitAnnotation(asmDescByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_CALLABLE), true);
         JvmCodegenUtil.writeAbiVersion(av);
         AnnotationVisitor array = av.visitArray(JvmAnnotationNames.DATA_FIELD_NAME);
-        for (String string : BitEncoding.encodeBytes(SerializationUtil.serializeCallableData(nameResolver, callableProto))) {
+        for (String string : BitEncoding.encodeBytes(serializer.serialize(callableProto))) {
             array.visit(null, string);
         }
         array.visitEnd();

compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java

@@ -66,8 +66,8 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver;
-import org.jetbrains.kotlin.serialization.*;
+import org.jetbrains.kotlin.serialization.DescriptorSerializer;
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver;
+import org.jetbrains.kotlin.serialization.ProtoBuf;
 import org.jetbrains.kotlin.serialization.jvm.BitEncoding;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.checker.JetTypeChecker;
@@ -259,10 +259,6 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         ProtoBuf.Class classProto = serializer.classProto(descriptor).build();
 
-        StringTable strings = serializer.getStringTable();
-        NameResolver nameResolver = new NameResolver(strings.serializeSimpleNames(), strings.serializeQualifiedNames());
-        ClassData data = new ClassData(nameResolver, classProto);
-
         AnnotationVisitor av = v.getVisitor().visitAnnotation(asmDescByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_CLASS), true);
         JvmCodegenUtil.writeAbiVersion(av);
         //noinspection ConstantConditions
@@ -274,7 +270,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             );
         }
         AnnotationVisitor array = av.visitArray(JvmAnnotationNames.DATA_FIELD_NAME);
-        for (String string : BitEncoding.encodeBytes(SerializationUtil.serializeClassData(data))) {
+        for (String string : BitEncoding.encodeBytes(serializer.serialize(classProto))) {
             array.visit(null, string);
         }
         array.visitEnd();

compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassPartCodegen.kt

@@ -27,9 +27,6 @@ import org.jetbrains.kotlin.psi.JetNamedFunction
 import org.jetbrains.kotlin.psi.JetProperty
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
-import org.jetbrains.kotlin.serialization.PackageData
-import org.jetbrains.kotlin.serialization.SerializationUtil
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver
 import org.jetbrains.kotlin.serialization.jvm.BitEncoding
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
@@ -98,18 +95,14 @@ public class MultifileClassPartCodegen(
 
         if (packageProto.memberCount == 0) return
 
-        val strings = serializer.stringTable
-        val nameResolver = NameResolver(strings.serializeSimpleNames(), strings.serializeQualifiedNames())
-        val data = PackageData(nameResolver, packageProto)
-
         val av = v.newAnnotation(AsmUtil.asmDescByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_MULTIFILE_CLASS_PART), true)
         JvmCodegenUtil.writeAbiVersion(av)
         av.visit(JvmAnnotationNames.MULTIFILE_CLASS_NAME_FIELD_NAME, multifileClassFqName.shortName().asString())
         val dataArray = av.visitArray(JvmAnnotationNames.DATA_FIELD_NAME)
-        for (string in BitEncoding.encodeBytes(SerializationUtil.serializePackageData(data))) {
+        for (string in BitEncoding.encodeBytes(serializer.serialize(packageProto))) {
             dataArray.visit(null, string)
         }
         dataArray.visitEnd()
         av.visitEnd()
     }
-}
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java

@@ -53,8 +53,8 @@ import org.jetbrains.kotlin.resolve.MemberComparator;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.serialization.*;
+import org.jetbrains.kotlin.serialization.DescriptorSerializer;
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver;
+import org.jetbrains.kotlin.serialization.ProtoBuf;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedSimpleFunctionDescriptor;
@@ -296,14 +296,10 @@ public class PackageCodegen {
 
         //if (packageProto.getMemberCount() == 0) return;
 
-        StringTable strings = serializer.getStringTable();
-        NameResolver nameResolver = new NameResolver(strings.serializeSimpleNames(), strings.serializeQualifiedNames());
-        PackageData data = new PackageData(nameResolver, packageProto);
-
         AnnotationVisitor av = v.newAnnotation(asmDescByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_PACKAGE), true);
         JvmCodegenUtil.writeAbiVersion(av);
         AnnotationVisitor array = av.visitArray(JvmAnnotationNames.DATA_FIELD_NAME);
-        for (String string : BitEncoding.encodeBytes(SerializationUtil.serializePackageData(data))) {
+        for (String string : BitEncoding.encodeBytes(serializer.serialize(packageProto))) {
             array.visit(null, string);
         }
         array.visitEnd();

compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java

@@ -31,8 +31,8 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationsImpl;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.serialization.*;
+import org.jetbrains.kotlin.serialization.DescriptorSerializer;
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver;
+import org.jetbrains.kotlin.serialization.ProtoBuf;
 import org.jetbrains.kotlin.serialization.jvm.BitEncoding;
 import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -127,14 +127,10 @@ public class PackagePartCodegen extends MemberCodegen<JetFile> {
 
         if (packageProto.getMemberCount() == 0) return;
 
-        StringTable strings = serializer.getStringTable();
-        NameResolver nameResolver = new NameResolver(strings.serializeSimpleNames(), strings.serializeQualifiedNames());
-        PackageData data = new PackageData(nameResolver, packageProto);
-
         AnnotationVisitor av = v.newAnnotation(asmDescByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_FILE_FACADE), true);
         JvmCodegenUtil.writeAbiVersion(av);
         AnnotationVisitor array = av.visitArray(JvmAnnotationNames.DATA_FIELD_NAME);
-        for (String string : BitEncoding.encodeBytes(SerializationUtil.serializePackageData(data))) {
+        for (String string : BitEncoding.encodeBytes(serializer.serialize(packageProto))) {
             array.visit(null, string);
         }
         array.visitEnd();

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.builtins.BuiltInsSerializedResourcePaths
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -39,11 +40,9 @@ import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
-import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.SerializationUtil
 import org.jetbrains.kotlin.utils.recursePostOrder
 import java.io.ByteArrayOutputStream
 import java.io.File
@@ -136,8 +135,7 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
               BuiltInsSerializedResourcePaths.fallbackPaths.getPackageFilePath(fqName))
 
         val nameStream = ByteArrayOutputStream()
-        val strings = serializer.getStringTable()
+        serializer.serializeStringTable(nameStream)
-        SerializationUtil.serializeStringTable(nameStream, strings.serializeSimpleNames(), strings.serializeQualifiedNames())
         write(destDir, BuiltInsSerializedResourcePaths.getStringTableFilePath(fqName), nameStream,
               BuiltInsSerializedResourcePaths.fallbackPaths.getStringTableFilePath(fqName))
     }

compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.serialization;
 
+import com.google.protobuf.MessageLite;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -27,7 +28,11 @@ import org.jetbrains.kotlin.resolve.MemberComparator;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.NullValue;
 import org.jetbrains.kotlin.types.*;
+import org.jetbrains.kotlin.utils.UtilsPackage;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -48,6 +53,24 @@ public class DescriptorSerializer {
         this.extension = extension;
     }
 
+    @NotNull
+    public byte[] serialize(@NotNull MessageLite message) {
+        try {
+            ByteArrayOutputStream result = new ByteArrayOutputStream();
+            serializeStringTable(result);
+            message.writeTo(result);
+            return result.toByteArray();
+        }
+        catch (IOException e) {
+            throw UtilsPackage.rethrow(e);
+        }
+    }
+
+    public void serializeStringTable(@NotNull OutputStream out) throws IOException {
+        stringTable.serializeSimpleNames().writeDelimitedTo(out);
+        stringTable.serializeQualifiedNames().writeDelimitedTo(out);
+    }
+
     @NotNull
     public static DescriptorSerializer createTopLevel(@NotNull SerializerExtension extension) {
         return new DescriptorSerializer(new StringTable(extension), new Interner<TypeParameterDescriptor>(), extension);

compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializationUtil.java

@@ -1,87 +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.serialization;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.serialization.deserialization.NameResolver;
-import org.jetbrains.kotlin.utils.UtilsPackage;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.OutputStream;
-
-public class SerializationUtil {
-    private SerializationUtil() {
-    }
-
-    @NotNull
-    public static byte[] serializeClassData(@NotNull ClassData classData) {
-        try {
-            ByteArrayOutputStream result = new ByteArrayOutputStream();
-            serializeNameResolver(result, classData.getNameResolver());
-            classData.getClassProto().writeTo(result);
-            return result.toByteArray();
-        }
-        catch (IOException e) {
-            throw UtilsPackage.rethrow(e);
-        }
-    }
-
-    @NotNull
-    public static byte[] serializePackageData(@NotNull PackageData packageData) {
-        try {
-            ByteArrayOutputStream result = new ByteArrayOutputStream();
-            serializeNameResolver(result, packageData.getNameResolver());
-            packageData.getPackageProto().writeTo(result);
-            return result.toByteArray();
-        }
-        catch (IOException e) {
-            throw UtilsPackage.rethrow(e);
-        }
-    }
-
-    @NotNull
-    public static byte[] serializeCallableData(@NotNull NameResolver nameResolver, @NotNull ProtoBuf.Callable callableProto) {
-        try {
-            ByteArrayOutputStream result = new ByteArrayOutputStream();
-            serializeNameResolver(result, nameResolver);
-            callableProto.writeTo(result);
-            return result.toByteArray();
-        }
-        catch (IOException e) {
-            throw UtilsPackage.rethrow(e);
-        }
-    }
-
-    private static void serializeNameResolver(@NotNull OutputStream out, @NotNull NameResolver nameResolver) {
-        serializeStringTable(out, nameResolver.getStringTable(), nameResolver.getQualifiedNameTable());
-    }
-
-    public static void serializeStringTable(
-            @NotNull OutputStream out,
-            @NotNull ProtoBuf.StringTable stringTable,
-            @NotNull ProtoBuf.QualifiedNameTable qualifiedNameTable
-    ) {
-        try {
-            stringTable.writeDelimitedTo(out);
-            qualifiedNameTable.writeDelimitedTo(out);
-        }
-        catch (IOException e) {
-            throw UtilsPackage.rethrow(e);
-        }
-    }
-}

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.SerializationUtil
 import org.jetbrains.kotlin.serialization.StringTable
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadata
@@ -50,10 +49,10 @@ public object KotlinJavascriptSerializationUtil {
     }
 
     private val STRING_TABLE_DEFAULT_BYTES = run {
-        val nameStream = ByteArrayOutputStream()
+        val serializer = DescriptorSerializer.createTopLevel(KotlinJavascriptSerializerExtension)
-        val strings = StringTable(KotlinJavascriptSerializerExtension)
+        val stream = ByteArrayOutputStream()
-        SerializationUtil.serializeStringTable(nameStream, strings.serializeSimpleNames(), strings.serializeQualifiedNames())
+        serializer.serializeStringTable(stream)
-        nameStream.toByteArray()
+        stream.toByteArray()
     }
 
     @JvmStatic
@@ -99,7 +98,7 @@ public object KotlinJavascriptSerializationUtil {
     public fun metadataAsString(moduleName: String, moduleDescriptor: ModuleDescriptor): String =
         KotlinJavascriptMetadataUtils.formatMetadataAsString(moduleName, moduleDescriptor.toBinaryMetadata())
 
-    fun serializePackage(module: ModuleDescriptor, fqName: FqName, writeFun: (String, ByteArrayOutputStream) -> Unit) {
+    fun serializePackage(module: ModuleDescriptor, fqName: FqName, writeFun: (String, ByteArray) -> Unit) {
         val packageView = module.getPackage(fqName)
 
         val skip: (DeclarationDescriptor) -> Boolean = { DescriptorUtils.getContainingModule(it) != module }
@@ -112,29 +111,27 @@ public object KotlinJavascriptSerializationUtil {
             override fun writeClass(classDescriptor: ClassDescriptor, classProto: ProtoBuf.Class) {
                 val stream = ByteArrayOutputStream()
                 classProto.writeTo(stream)
-                writeFun(getFileName(classDescriptor), stream)
+                writeFun(getFileName(classDescriptor), stream.toByteArray())
             }
         }, skip)
 
         val packageStream = ByteArrayOutputStream()
         val fragments = packageView.fragments
         val packageProto = serializer.packageProto(fragments, skip).build() ?: error("Package fragments not serialized: $fragments")
-        if (packageProto.getMemberCount() > 0) {
+        if (packageProto.memberCount > 0) {
             packageProto.writeTo(packageStream)
-            writeFun(KotlinJavascriptSerializedResourcePaths.getPackageFilePath(fqName), packageStream)
+            writeFun(KotlinJavascriptSerializedResourcePaths.getPackageFilePath(fqName), packageStream.toByteArray())
         }
 
-        val nameStream = ByteArrayOutputStream()
+        val strings = serializer.stringTable
-        val strings = serializer.getStringTable()
-
         serializeClassNamesInPackage(fqName, fragments, strings, skip, writeFun)
 
-        val simpleNames = strings.serializeSimpleNames()
+        val nameStream = ByteArrayOutputStream()
-        val qualifiedNames = strings.serializeQualifiedNames()
+        serializer.serializeStringTable(nameStream)
+        val stringBytes = nameStream.toByteArray()
 
-        if (simpleNames.getStringCount() > 0 || qualifiedNames.getQualifiedNameCount() > 0) {
+        if (!stringBytes.isEmpty()) {
-            SerializationUtil.serializeStringTable(nameStream, simpleNames, qualifiedNames)
+            writeFun(KotlinJavascriptSerializedResourcePaths.getStringTableFilePath(fqName), stringBytes)
-            writeFun(KotlinJavascriptSerializedResourcePaths.getStringTableFilePath(fqName), nameStream)
         }
     }
 
@@ -143,7 +140,7 @@ public object KotlinJavascriptSerializationUtil {
             packageFragments: Collection<PackageFragmentDescriptor>,
             stringTable: StringTable,
             skip: (DeclarationDescriptor) -> Boolean,
-            writeFun: (String, ByteArrayOutputStream) -> Unit
+            writeFun: (String, ByteArray) -> Unit
     ) {
         val classes = packageFragments.flatMap {
             it.getMemberScope().getDescriptors(DescriptorKindFilter.CLASSIFIERS).filterIsInstance<ClassDescriptor>()
@@ -157,10 +154,10 @@ public object KotlinJavascriptSerializationUtil {
 
         val classesProto = builder.build()
 
-        if (classesProto.getClassNameCount() > 0) {
+        if (classesProto.classNameCount > 0) {
             val stream = ByteArrayOutputStream()
             classesProto.writeTo(stream)
-            writeFun(KotlinJavascriptSerializedResourcePaths.getClassesInPackageFilePath(fqName), stream)
+            writeFun(KotlinJavascriptSerializedResourcePaths.getClassesInPackageFilePath(fqName), stream.toByteArray())
         }
     }
 
@@ -173,7 +170,7 @@ public object KotlinJavascriptSerializationUtil {
 
         DescriptorUtils.getPackagesFqNames(this).forEach {
             serializePackage(this, it) {
-                fileName, stream -> contentMap[fileName] = stream.toByteArray()
+                fileName, bytes -> contentMap[fileName] = bytes
             }
         }