Write ProtoBuf.Package to .kotlin_package

Instead of a delimited list of callables. Also some minor refactorings

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java

@@ -133,8 +133,8 @@ public final class DeserializedDescriptorResolver {
         if (packageData == null) {
             return null;
         }
-        return DeserializedPackageMemberScope.createScopeFromPackageData(packageDescriptor, packageData, javaDescriptorFinder,
+        return new DeserializedPackageMemberScope(storageManager, packageDescriptor, annotationDeserializer, javaDescriptorFinder,
-                                                                         annotationDeserializer, storageManager);
+                                                  packageData);
     }
 
     @Nullable

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java

@@ -5,7 +5,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.*;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager;
 import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
@@ -13,23 +12,8 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.List;
 
 public class DeserializedPackageMemberScope extends DeserializedMemberScope {
-    @NotNull
-    public static DeserializedPackageMemberScope createScopeFromPackageData(
-            @NotNull NamespaceDescriptor packageDescriptor,
-            @NotNull PackageData packageData,
-            @NotNull DescriptorFinder descriptorFinder,
-            @NotNull AnnotationDeserializer deserializer,
-            @NotNull LockBasedStorageManager storageManager
-    ) {
-        DescriptorDeserializer descriptorDeserializer = DescriptorDeserializer
-                .create(storageManager, packageDescriptor, packageData.getNameResolver(), descriptorFinder, deserializer);
-        List<ProtoBuf.Callable> memberList = packageData.getPackageProto().getMemberList();
-        return new DeserializedPackageMemberScope(storageManager, packageDescriptor, descriptorDeserializer, memberList, descriptorFinder);
-    }
-
     private final DescriptorFinder descriptorFinder;
 
     private final FqName packageFqName;
@@ -37,15 +21,29 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope {
     public DeserializedPackageMemberScope(
             @NotNull StorageManager storageManager,
             @NotNull NamespaceDescriptor packageDescriptor,
-            @NotNull DescriptorDeserializer deserializer,
+            @NotNull AnnotationDeserializer annotationDeserializer,
-            @NotNull List<ProtoBuf.Callable> membersList,
+            @NotNull DescriptorFinder descriptorFinder,
-            @NotNull DescriptorFinder descriptorFinder
+            @NotNull ProtoBuf.Package proto,
+            @NotNull NameResolver nameResolver
     ) {
-        super(storageManager, packageDescriptor, deserializer, membersList);
+        super(storageManager, packageDescriptor,
+              DescriptorDeserializer.create(storageManager, packageDescriptor, nameResolver, descriptorFinder, annotationDeserializer),
+              proto.getMemberList());
         this.descriptorFinder = descriptorFinder;
         this.packageFqName = DescriptorUtils.getFQName(packageDescriptor).toSafe();
     }
 
+    public DeserializedPackageMemberScope(
+            @NotNull StorageManager storageManager,
+            @NotNull NamespaceDescriptor packageDescriptor,
+            @NotNull AnnotationDeserializer annotationDeserializer,
+            @NotNull DescriptorFinder descriptorFinder,
+            @NotNull PackageData packageData
+    ) {
+        this(storageManager, packageDescriptor, annotationDeserializer, descriptorFinder, packageData.getPackageProto(),
+             packageData.getNameResolver());
+    }
+
     @Nullable
     @Override
     protected ClassifierDescriptor getClassDescriptor(@NotNull Name name) {

compiler/frontend/src/org/jetbrains/jet/lang/types/lang/BuiltinsNamespaceDescriptorImpl.java

@@ -4,7 +4,6 @@ import com.intellij.openapi.util.Computable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.*;
-import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
@@ -23,112 +22,101 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer.UNSUPPORTED;
+
 class BuiltinsNamespaceDescriptorImpl extends AbstractNamespaceDescriptorImpl {
 
     private final DeserializedPackageMemberScope members;
     private final NameResolver nameResolver;
 
-    public BuiltinsNamespaceDescriptorImpl(@NotNull final StorageManager storageManager, @NotNull NamespaceDescriptor containingDeclaration) {
+    public BuiltinsNamespaceDescriptorImpl(@NotNull StorageManager storageManager, @NotNull NamespaceDescriptor containingDeclaration) {
         super(containingDeclaration, Collections.<AnnotationDescriptor>emptyList(), KotlinBuiltIns.BUILT_INS_PACKAGE_NAME);
 
-        try {
+        nameResolver = NameSerializationUtil.deserializeNameResolver(getStream(BuiltInsSerializationUtil.getNameTableFilePath(this)));
-            nameResolver = NameSerializationUtil.deserializeNameResolver(getStream(BuiltInsSerializationUtil.getNameTableFilePath(this)));
 
-            final NotNullLazyValue<Collection<Name>> classNames = storageManager.createLazyValue(new Computable<Collection<Name>>() {
+        final NotNullLazyValue<Collection<Name>> classNames = storageManager.createLazyValue(new Computable<Collection<Name>>() {
-                @Override
+            @Override
-                @NotNull
+            @NotNull
-                public Collection<Name> compute() {
+            public Collection<Name> compute() {
-                    InputStream in = getStream(BuiltInsSerializationUtil.getClassNamesFilePath(BuiltinsNamespaceDescriptorImpl.this));
+                InputStream in = getStream(BuiltInsSerializationUtil.getClassNamesFilePath(BuiltinsNamespaceDescriptorImpl.this));
 
+                try {
+                    DataInputStream data = new DataInputStream(in);
                     try {
-                        DataInputStream data = new DataInputStream(in);
+                        int size = data.readInt();
-                        try {
+                        List<Name> result = new ArrayList<Name>(size);
-                            int size = data.readInt();
+                        for (int i = 0; i < size; i++) {
-                            List<Name> result = new ArrayList<Name>(size);
+                            result.add(nameResolver.getName(data.readInt()));
-                            for (int i = 0; i < size; i++) {
-                                result.add(nameResolver.getName(data.readInt()));
-                            }
-                            return result;
-                        }
-                        finally {
-                            data.close();
                         }
+                        return result;
                     }
-                    catch (IOException e) {
+                    finally {
-                        throw new IllegalStateException(e);
+                        data.close();
                     }
                 }
-            });
+                catch (IOException e) {
+                    throw new IllegalStateException(e);
+                }
+            }
+        });
 
-            DescriptorFinder descriptorFinder = new AbstractDescriptorFinder(storageManager, AnnotationDeserializer.UNSUPPORTED) {
+        DescriptorFinder descriptorFinder = new AbstractDescriptorFinder(storageManager, UNSUPPORTED) {
-                @Nullable
+            @Nullable
-                @Override
+            @Override
-                protected ClassData getClassData(@NotNull ClassId classId) {
+            protected ClassData getClassData(@NotNull ClassId classId) {
-                    InputStream stream = getStreamNullable(BuiltInsSerializationUtil.getClassMetadataPath(classId));
+                InputStream stream = getStreamNullable(BuiltInsSerializationUtil.getClassMetadataPath(classId));
-                    if (stream == null) {
+                if (stream == null) {
+                    return null;
+                }
+
+                try {
+                    ProtoBuf.Class classProto = ProtoBuf.Class.parseFrom(stream);
+
+                    Name expectedShortName = classId.getRelativeClassName().shortName();
+                    Name actualShortName = nameResolver.getName(classProto.getName());
+                    if (!actualShortName.isSpecial() && !actualShortName.equals(expectedShortName)) {
+                        // Workaround for case-insensitive file systems,
+                        // otherwise we'd find "Collection" for "collection" etc
                         return null;
                     }
 
-                    try {
+                    return new ClassData(nameResolver, classProto);
-                        ProtoBuf.Class classProto = ProtoBuf.Class.parseFrom(stream);
-
-                        Name expectedShortName = classId.getRelativeClassName().shortName();
-                        Name actualShortName = nameResolver.getName(classProto.getName());
-                        if (!actualShortName.isSpecial() && !actualShortName.equals(expectedShortName)) {
-                            // Workaround for case-insensitive file systems,
-                            // otherwise we'd find "Collection" for "collection" etc
-                            return null;
-                        }
-
-                        return new ClassData(nameResolver, classProto);
-                    }
-                    catch (IOException e) {
-                        throw new IllegalStateException(e);
-                    }
                 }
-
+                catch (IOException e) {
-                @Nullable
+                    throw new IllegalStateException(e);
-                @Override
-                public NamespaceDescriptor findPackage(@NotNull FqName fqName) {
-                    return fqName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) ? BuiltinsNamespaceDescriptorImpl.this : null;
                 }
+            }
 
-                @NotNull
+            @Nullable
-                @Override
+            @Override
-                public Collection<Name> getClassNames(@NotNull FqName packageName) {
+            public NamespaceDescriptor findPackage(@NotNull FqName fqName) {
-                    return packageName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME)
+                return fqName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) ? BuiltinsNamespaceDescriptorImpl.this : null;
-                           ? classNames.compute()
+            }
-                           : Collections.<Name>emptyList();
-                }
-            };
 
-            members = new DeserializedPackageMemberScope(
+            @NotNull
-                    storageManager,
+            @Override
-                    this,
+            public Collection<Name> getClassNames(@NotNull FqName packageName) {
-                    DescriptorDeserializer.create(storageManager, this, nameResolver, descriptorFinder, AnnotationDeserializer.UNSUPPORTED),
+                return packageName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME)
-                    loadCallables(), descriptorFinder
+                       ? classNames.compute()
-            );
+                       : Collections.<Name>emptyList();
+            }
+        };
+
+        members = new DeserializedPackageMemberScope(storageManager, this, UNSUPPORTED, descriptorFinder, loadPackage(), nameResolver);
+    }
+
+    @NotNull
+    private ProtoBuf.Package loadPackage() {
+        String packageFilePath = BuiltInsSerializationUtil.getPackageFilePath(this);
+        InputStream stream = getStream(packageFilePath);
+        try {
+            return ProtoBuf.Package.parseFrom(stream);
         }
         catch (IOException e) {
             throw new IllegalStateException(e);
         }
     }
 
-    private List<ProtoBuf.Callable> loadCallables() throws IOException {
-        String packageFilePath = BuiltInsSerializationUtil.getPackageFilePath(this);
-        InputStream stream = getStream(packageFilePath);
-
-        List<ProtoBuf.Callable> callables = new ArrayList<ProtoBuf.Callable>();
-        while (true) {
-            ProtoBuf.Callable callable = ProtoBuf.Callable.parseDelimitedFrom(stream);
-            if (callable == null) {
-                break;
-            }
-            callables.add(callable);
-        }
-        return callables;
-    }
-
     @NotNull
     @Override
     public JetScope getMemberScope() {

generators/org/jetbrains/jet/generators/builtins/BuiltInsSerializer.java

@@ -9,7 +9,10 @@ import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.descriptors.serialization.*;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil;
@@ -26,6 +29,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Pattern;
 
+@SuppressWarnings("UseOfSystemOutOrSystemErr")
 public class BuiltInsSerializer {
     private static final String BUILT_INS_SRC_DIR = "idea/builtinsSrc";
     private static final String DEST_DIR = "compiler/frontend/builtins";
@@ -50,8 +54,6 @@ public class BuiltInsSerializer {
 
         DescriptorValidator.validate(namespace);
 
-        List<DeclarationDescriptor> allDescriptors = DescriptorSerializer.sort(namespace.getMemberScope().getAllDescriptors());
-
         final File destDir = new File(DEST_DIR);
         if (!FileUtil.delete(destDir)) {
             System.err.println("Could not delete: " + destDir);
@@ -70,13 +72,13 @@ public class BuiltInsSerializer {
         });
 
         final List<Name> classNames = new ArrayList<Name>();
+        List<DeclarationDescriptor> allDescriptors = DescriptorSerializer.sort(namespace.getMemberScope().getAllDescriptors());
         ClassSerializationUtil.serializeClasses(allDescriptors, serializer, new ClassSerializationUtil.Sink() {
             @Override
             public void writeClass(@NotNull ClassDescriptor classDescriptor, @NotNull ProtoBuf.Class classProto) {
                 try {
                     ByteArrayOutputStream stream = new ByteArrayOutputStream();
                     classProto.writeTo(stream);
-
                     write(destDir, getFileName(classDescriptor), stream);
 
                     if (DescriptorUtils.isTopLevelDeclaration(classDescriptor)) {
@@ -90,7 +92,27 @@ public class BuiltInsSerializer {
         });
 
         ByteArrayOutputStream classNamesStream = new ByteArrayOutputStream();
-        DataOutputStream data = new DataOutputStream(classNamesStream);
+        writeClassNames(serializer, classNames, classNamesStream);
+        write(destDir, BuiltInsSerializationUtil.getClassNamesFilePath(namespace), classNamesStream);
+
+        ByteArrayOutputStream packageStream = new ByteArrayOutputStream();
+        ProtoBuf.Package packageProto = serializer.packageProto(namespace).build();
+        packageProto.writeTo(packageStream);
+        write(destDir, BuiltInsSerializationUtil.getPackageFilePath(namespace), packageStream);
+
+        ByteArrayOutputStream nameStream = new ByteArrayOutputStream();
+        NameSerializationUtil.serializeNameTable(nameStream, serializer.getNameTable());
+        write(destDir, BuiltInsSerializationUtil.getNameTableFilePath(namespace), nameStream);
+
+        System.out.println("Total bytes written: " + totalSize + " to " + totalFiles + " files");
+    }
+
+    private static void writeClassNames(
+            @NotNull DescriptorSerializer serializer,
+            @NotNull List<Name> classNames,
+            @NotNull ByteArrayOutputStream stream
+    ) throws IOException {
+        DataOutputStream data = new DataOutputStream(stream);
         try {
             data.writeInt(classNames.size());
             for (Name className : classNames) {
@@ -101,35 +123,17 @@ public class BuiltInsSerializer {
         finally {
             data.close();
         }
-
-        ByteArrayOutputStream stream = new ByteArrayOutputStream();
-        for (DeclarationDescriptor descriptor : allDescriptors) {
-            if (descriptor instanceof CallableMemberDescriptor) {
-                CallableMemberDescriptor callableMemberDescriptor = (CallableMemberDescriptor) descriptor;
-                ProtoBuf.Callable proto = serializer.callableProto(callableMemberDescriptor).build();
-                proto.writeDelimitedTo(stream);
-            }
-        }
-
-        write(destDir, BuiltInsSerializationUtil.getPackageFilePath(namespace), stream);
-
-        ByteArrayOutputStream nameStream = new ByteArrayOutputStream();
-        NameSerializationUtil.serializeNameTable(nameStream, serializer.getNameTable());
-        write(destDir, BuiltInsSerializationUtil.getNameTableFilePath(namespace), nameStream);
-
-        write(destDir, BuiltInsSerializationUtil.getClassNamesFilePath(namespace), classNamesStream);
-
-        System.out.println("Total bytes written: " + totalSize + " to " + totalFiles + " files");
     }
 
-    private static void write(File destDir, String fileName, ByteArrayOutputStream stream) throws IOException {
+    private static void write(@NotNull File destDir, @NotNull String fileName, @NotNull ByteArrayOutputStream stream) throws IOException {
         totalSize += stream.size();
         totalFiles++;
         FileUtil.writeToFile(new File(destDir, fileName), stream.toByteArray());
         System.out.println(stream.size() + " bytes written to " + fileName);
     }
 
-    private static String getFileName(ClassDescriptor classDescriptor) {
+    @NotNull
+    private static String getFileName(@NotNull ClassDescriptor classDescriptor) {
         return BuiltInsSerializationUtil.getClassMetadataPath(ClassSerializationUtil.getClassId(classDescriptor));
     }
 }