Write ProtoBuf.Package to .kotlin_package

Instead of a delimited list of callables. Also some minor refactorings
2013-07-16 22:27:34 +04:00
parent be2636de0f
commit eff99e563b
5 changed files with 117 additions and 127 deletions
@@ -133,8 +133,8 @@ public final class DeserializedDescriptorResolver {
        if (packageData == null) {
            return null;
        }
-        return DeserializedPackageMemberScope.createScopeFromPackageData(packageDescriptor, packageData, javaDescriptorFinder,
-                                                                         annotationDeserializer, storageManager);
+        return new DeserializedPackageMemberScope(storageManager, packageDescriptor, annotationDeserializer, javaDescriptorFinder,
+                                                  packageData);
    }

    @Nullable
@@ -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 List<ProtoBuf.Callable> membersList,
-            @NotNull DescriptorFinder descriptorFinder
+            @NotNull AnnotationDeserializer annotationDeserializer,
+            @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) {
@@ -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>>() {
-                @Override
-                @NotNull
-                public Collection<Name> compute() {
-                    InputStream in = getStream(BuiltInsSerializationUtil.getClassNamesFilePath(BuiltinsNamespaceDescriptorImpl.this));
+        final NotNullLazyValue<Collection<Name>> classNames = storageManager.createLazyValue(new Computable<Collection<Name>>() {
+            @Override
+            @NotNull
+            public Collection<Name> compute() {
+                InputStream in = getStream(BuiltInsSerializationUtil.getClassNamesFilePath(BuiltinsNamespaceDescriptorImpl.this));

+                try {
+                    DataInputStream data = new DataInputStream(in);
                    try {
-                        DataInputStream data = new DataInputStream(in);
-                        try {
-                            int size = data.readInt();
-                            List<Name> result = new ArrayList<Name>(size);
-                            for (int i = 0; i < size; i++) {
-                                result.add(nameResolver.getName(data.readInt()));
-                            }
-                            return result;
-                        }
-                        finally {
-                            data.close();
+                        int size = data.readInt();
+                        List<Name> result = new ArrayList<Name>(size);
+                        for (int i = 0; i < size; i++) {
+                            result.add(nameResolver.getName(data.readInt()));
                        }
+                        return result;
                    }
-                    catch (IOException e) {
-                        throw new IllegalStateException(e);
+                    finally {
+                        data.close();
                    }
                }
-            });
+                catch (IOException e) {
+                    throw new IllegalStateException(e);
+                }
+            }
+        });

-            DescriptorFinder descriptorFinder = new AbstractDescriptorFinder(storageManager, AnnotationDeserializer.UNSUPPORTED) {
-                @Nullable
-                @Override
-                protected ClassData getClassData(@NotNull ClassId classId) {
-                    InputStream stream = getStreamNullable(BuiltInsSerializationUtil.getClassMetadataPath(classId));
-                    if (stream == null) {
+        DescriptorFinder descriptorFinder = new AbstractDescriptorFinder(storageManager, UNSUPPORTED) {
+            @Nullable
+            @Override
+            protected ClassData getClassData(@NotNull ClassId classId) {
+                InputStream stream = getStreamNullable(BuiltInsSerializationUtil.getClassMetadataPath(classId));
+                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 {
-                        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);
-                    }
+                    return new ClassData(nameResolver, classProto);
                }
-
-                @Nullable
-                @Override
-                public NamespaceDescriptor findPackage(@NotNull FqName fqName) {
-                    return fqName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) ? BuiltinsNamespaceDescriptorImpl.this : null;
+                catch (IOException e) {
+                    throw new IllegalStateException(e);
                }
+            }

-                @NotNull
-                @Override
-                public Collection<Name> getClassNames(@NotNull FqName packageName) {
-                    return packageName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME)
-                           ? classNames.compute()
-                           : Collections.<Name>emptyList();
-                }
-            };
+            @Nullable
+            @Override
+            public NamespaceDescriptor findPackage(@NotNull FqName fqName) {
+                return fqName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) ? BuiltinsNamespaceDescriptorImpl.this : null;
+            }

-            members = new DeserializedPackageMemberScope(
-                    storageManager,
-                    this,
-                    DescriptorDeserializer.create(storageManager, this, nameResolver, descriptorFinder, AnnotationDeserializer.UNSUPPORTED),
-                    loadCallables(), descriptorFinder
-            );
+            @NotNull
+            @Override
+            public Collection<Name> getClassNames(@NotNull FqName packageName) {
+                return packageName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME)
+                       ? 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() {