Rename: AnnotationDeserializer, ConstantDeserializer -> *Loader

2014-06-17 16:04:11 +04:00
parent 2673510e8b
commit f8e5fa1b2f
18 changed files with 110 additions and 127 deletions
@@ -31,12 +31,12 @@ public abstract class AbstractDescriptorFinder implements DescriptorFinder {

    public AbstractDescriptorFinder(
            @NotNull StorageManager storageManager,
-            @NotNull AnnotationDeserializer annotationDeserializer,
-            @NotNull ConstantDeserializer constantDeserializer,
+            @NotNull AnnotationLoader annotationLoader,
+            @NotNull ConstantLoader constantLoader,
            @NotNull PackageFragmentProvider packageFragmentProvider
    ) {
        final DeserializationGlobalContext deserializationGlobalContext =
-                new DeserializationGlobalContext(storageManager, this, annotationDeserializer, constantDeserializer,
+                new DeserializationGlobalContext(storageManager, this, annotationLoader, constantLoader,
                                                 packageFragmentProvider, MemberFilter.ALWAYS_TRUE);
        this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function1<ClassId, ClassDescriptor>() {
            @Override
@@ -20,10 +20,7 @@ import kotlin.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes;
-import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
-import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPropertyDescriptor;
-import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedSimpleFunctionDescriptor;
-import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor;
+import org.jetbrains.jet.descriptors.serialization.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl;
@@ -42,8 +39,6 @@ import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable;
 import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter;
 import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.*;

-import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind;
-
 public class DescriptorDeserializer {

    private final DeserializationContextWithTypes context;
@@ -144,10 +139,9 @@ public class DescriptorDeserializer {
                            DeclarationDescriptor containingDeclaration = context.getContainingDeclaration();
                            assert containingDeclaration instanceof ClassOrPackageFragmentDescriptor
                                    : "Only members in classes or package fragments should be serialized: " + containingDeclaration;
-                            return context.getConstantDeserializer().loadPropertyConstant(
-                                                            (ClassOrPackageFragmentDescriptor) containingDeclaration,
-                                                            proto, context.getNameResolver(),
-                                                            AnnotatedCallableKind.PROPERTY);
+                            return context.getConstantLoader().loadPropertyConstant(
+                                    (ClassOrPackageFragmentDescriptor) containingDeclaration, proto,
+                                    context.getNameResolver(), AnnotatedCallableKind.PROPERTY);
                        }
                    })
            );
@@ -162,9 +156,7 @@ public class DescriptorDeserializer {
    private CallableMemberDescriptor loadFunction(@NotNull Callable proto) {
        int flags = proto.getFlags();
        DeserializedSimpleFunctionDescriptor function = DeserializedSimpleFunctionDescriptor.create(
-                context.getContainingDeclaration(), proto,
-                context.getAnnotationDeserializer(),
-                context.getNameResolver()
+                context.getContainingDeclaration(), proto, context.getAnnotationLoader(), context.getNameResolver()
        );
        List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(proto.getTypeParameterCount());
        DeserializationContextWithTypes local = context.childContext(function, proto.getTypeParameterList(), typeParameters);
@@ -209,7 +201,7 @@ public class DescriptorDeserializer {

    @NotNull
    private Annotations getAnnotations(@NotNull Callable proto, int flags, @NotNull AnnotatedCallableKind kind) {
-        return getAnnotations(context.getContainingDeclaration(), proto, flags, kind, context.getAnnotationDeserializer(), context.getNameResolver());
+        return getAnnotations(context.getContainingDeclaration(), proto, flags, kind, context.getAnnotationLoader(), context.getNameResolver());
    }

    public static Annotations getAnnotations(
@@ -217,15 +209,13 @@ public class DescriptorDeserializer {
            @NotNull Callable proto,
            int flags,
            @NotNull AnnotatedCallableKind kind,
-            @NotNull AnnotationDeserializer annotationDeserializer,
+            @NotNull AnnotationLoader annotationLoader,
            @NotNull NameResolver nameResolver
    ) {
        assert containingDeclaration instanceof ClassOrPackageFragmentDescriptor
                : "Only members in classes or package fragments should be serialized: " + containingDeclaration;
-        return Flags.HAS_ANNOTATIONS.get(flags)
-               ? annotationDeserializer
-                       .loadCallableAnnotations((ClassOrPackageFragmentDescriptor) containingDeclaration, proto, nameResolver, kind)
-               : Annotations.EMPTY;
+        return Flags.HAS_ANNOTATIONS.get(flags) ? annotationLoader.loadCallableAnnotations(
+                (ClassOrPackageFragmentDescriptor) containingDeclaration, proto, nameResolver, kind) : Annotations.EMPTY;
    }

    @NotNull
@@ -283,9 +273,8 @@ public class DescriptorDeserializer {
            @NotNull AnnotatedCallableKind kind,
            @NotNull Callable.ValueParameter valueParameter
    ) {
-        return Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags())
-               ? context.getAnnotationDeserializer()
-                        .loadValueParameterAnnotations(classOrPackage, callable, context.getNameResolver(), kind, valueParameter)
+        return Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags()) ? context.getAnnotationLoader()
+                       .loadValueParameterAnnotations(classOrPackage, callable, context.getNameResolver(), kind, valueParameter)
               : Annotations.EMPTY;
    }
 }
@@ -17,11 +17,10 @@
 package org.jetbrains.jet.descriptors.serialization.context

 import org.jetbrains.jet.storage.StorageManager
-import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer
+import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationLoader
 import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider
 import org.jetbrains.jet.descriptors.serialization.DescriptorFinder
 import org.jetbrains.jet.descriptors.serialization.NameResolver
-import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantDeserializer
 import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import org.jetbrains.jet.descriptors.serialization.TypeDeserializer
@@ -29,19 +28,19 @@ import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor
-import org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver
+import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantLoader

 public open class DeserializationGlobalContext(
        public val storageManager: StorageManager,
        public val descriptorFinder: DescriptorFinder,
-        public val annotationDeserializer: AnnotationDeserializer,
-        public val constantDeserializer: ConstantDeserializer,
+        public val annotationLoader: AnnotationLoader,
+        public val constantLoader: ConstantLoader,
        public val packageFragmentProvider: PackageFragmentProvider,
        public val memberFilter: MemberFilter
 ) {
    public fun withNameResolver(nameResolver: NameResolver): DeserializationContext {
-        return DeserializationContext(storageManager, descriptorFinder, annotationDeserializer,
-                                      constantDeserializer, packageFragmentProvider, memberFilter, nameResolver)
+        return DeserializationContext(storageManager, descriptorFinder, annotationLoader,
+                                      constantLoader, packageFragmentProvider, memberFilter, nameResolver)
    }
 }

@@ -49,13 +48,13 @@ public open class DeserializationGlobalContext(
 public open class DeserializationContext(
        storageManager: StorageManager,
        descriptorFinder: DescriptorFinder,
-        annotationDeserializer: AnnotationDeserializer,
-        constantDeserializer: ConstantDeserializer,
+        annotationLoader: AnnotationLoader,
+        constantLoader: ConstantLoader,
        packageFragmentProvider: PackageFragmentProvider,
        memberFilter: MemberFilter,
        public val nameResolver: NameResolver
-) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationDeserializer,
-                                 constantDeserializer, packageFragmentProvider, memberFilter) {
+) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader,
+                                 constantLoader, packageFragmentProvider, memberFilter) {
    fun withTypes(containingDeclaration: DeclarationDescriptor): DeserializationContextWithTypes {
        val typeDeserializer = TypeDeserializer(this, null, "Deserializer for ${containingDeclaration.getName()}",
                                                TypeDeserializer.TypeParameterResolver.NONE)
@@ -63,8 +62,8 @@ public open class DeserializationContext(
    }

    fun withTypes(containingDeclaration: DeclarationDescriptor, typeDeserializer: TypeDeserializer): DeserializationContextWithTypes {
-        return DeserializationContextWithTypes(storageManager, descriptorFinder, annotationDeserializer,
-                                               constantDeserializer, packageFragmentProvider, memberFilter,
+        return DeserializationContextWithTypes(storageManager, descriptorFinder, annotationLoader,
+                                               constantLoader, packageFragmentProvider, memberFilter,
                                               nameResolver, containingDeclaration,
                                               typeDeserializer)
    }
@@ -75,15 +74,15 @@ public open class DeserializationContext(
 class DeserializationContextWithTypes(
        storageManager: StorageManager,
        descriptorFinder: DescriptorFinder,
-        annotationDeserializer: AnnotationDeserializer,
-        constantDeserializer: ConstantDeserializer,
+        annotationLoader: AnnotationLoader,
+        constantLoader: ConstantLoader,
        packageFragmentProvider: PackageFragmentProvider,
        memberFilter: MemberFilter,
        nameResolver: NameResolver,
        val containingDeclaration: DeclarationDescriptor,
        val typeDeserializer: TypeDeserializer
-) : DeserializationContext(storageManager, descriptorFinder, annotationDeserializer,
-                           constantDeserializer, packageFragmentProvider, memberFilter, nameResolver) {
+) : DeserializationContext(storageManager, descriptorFinder, annotationLoader,
+                           constantLoader, packageFragmentProvider, memberFilter, nameResolver) {
    val deserializer: DescriptorDeserializer = DescriptorDeserializer(this)

    public fun childContext(
@@ -23,8 +23,8 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations;

-public interface AnnotationDeserializer {
-    AnnotationDeserializer UNSUPPORTED = new AnnotationDeserializer() {
+public interface AnnotationLoader {
+    AnnotationLoader UNSUPPORTED = new AnnotationLoader() {
        @NotNull
        @Override
        public Annotations loadClassAnnotations(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.Class classProto) {
@@ -23,8 +23,8 @@ import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
 import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;

-public interface ConstantDeserializer {
-    ConstantDeserializer UNSUPPORTED = new ConstantDeserializer() {
+public interface ConstantLoader {
+    ConstantLoader UNSUPPORTED = new ConstantLoader() {
        @Nullable
        @Override
        public CompileTimeConstant<?> loadPropertyConstant(
@@ -180,7 +180,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
        if (!Flags.HAS_ANNOTATIONS.get(classProto.getFlags())) {
            return Annotations.EMPTY;
        }
-        return context.getAnnotationDeserializer().loadClassAnnotations(this, classProto);
+        return context.getAnnotationLoader().loadClassAnnotations(this, classProto);
    }

    @NotNull
@@ -84,12 +84,12 @@ public class DeserializedSimpleFunctionDescriptor extends SimpleFunctionDescript
    public static DeserializedSimpleFunctionDescriptor create(
            @NotNull DeclarationDescriptor containingDeclaration,
            @NotNull ProtoBuf.Callable proto,
-            @NotNull AnnotationDeserializer annotationDeserializer,
+            @NotNull AnnotationLoader annotationLoader,
            @NotNull NameResolver nameResolver
    ) {
        Annotations annotations = DescriptorDeserializer.getAnnotations(containingDeclaration, proto, proto.getFlags(),
                                                                        AnnotatedCallableKind.FUNCTION,
-                                                                        annotationDeserializer,
+                                                                        annotationLoader,
                                                                        nameResolver);
        return new DeserializedSimpleFunctionDescriptor(
                containingDeclaration,