Get rid of SerializationUtil, move methods to DescriptorSerializer

2015-09-16 18:14:16 +03:00
parent 04b8991bdd
commit 93b5065cf5
9 changed files with 55 additions and 149 deletions
@@ -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();
@@ -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.deserialization.NameResolver;
+import org.jetbrains.kotlin.serialization.DescriptorSerializer;
+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();
@@ -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()
    }
-}
+}
@@ -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.deserialization.NameResolver;
+import org.jetbrains.kotlin.serialization.DescriptorSerializer;
+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();
@@ -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.deserialization.NameResolver;
+import org.jetbrains.kotlin.serialization.DescriptorSerializer;
+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();
@@ -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()
-        SerializationUtil.serializeStringTable(nameStream, strings.serializeSimpleNames(), strings.serializeQualifiedNames())
+        serializer.serializeStringTable(nameStream)
        write(destDir, BuiltInsSerializedResourcePaths.getStringTableFilePath(fqName), nameStream,
              BuiltInsSerializedResourcePaths.fallbackPaths.getStringTableFilePath(fqName))
    }
@@ -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);
@@ -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);
-        }
-    }
-}
@@ -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 strings = StringTable(KotlinJavascriptSerializerExtension)
-        SerializationUtil.serializeStringTable(nameStream, strings.serializeSimpleNames(), strings.serializeQualifiedNames())
-        nameStream.toByteArray()
+        val serializer = DescriptorSerializer.createTopLevel(KotlinJavascriptSerializerExtension)
+        val stream = ByteArrayOutputStream()
+        serializer.serializeStringTable(stream)
+        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.getStringTable()
-
+        val strings = serializer.stringTable
        serializeClassNamesInPackage(fqName, fragments, strings, skip, writeFun)

-        val simpleNames = strings.serializeSimpleNames()
-        val qualifiedNames = strings.serializeQualifiedNames()
+        val nameStream = ByteArrayOutputStream()
+        serializer.serializeStringTable(nameStream)
+        val stringBytes = nameStream.toByteArray()

-        if (simpleNames.getStringCount() > 0 || qualifiedNames.getQualifiedNameCount() > 0) {
-            SerializationUtil.serializeStringTable(nameStream, simpleNames, qualifiedNames)
-            writeFun(KotlinJavascriptSerializedResourcePaths.getStringTableFilePath(fqName), nameStream)
+        if (!stringBytes.isEmpty()) {
+            writeFun(KotlinJavascriptSerializedResourcePaths.getStringTableFilePath(fqName), stringBytes)
        }
    }

@@ -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
            }
        }