Rename: AnnotationDeserializer, ConstantDeserializer -> *Loader

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

@@ -53,7 +53,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodSignature;
 import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaPackageFragmentScope;
-import org.jetbrains.jet.lang.resolve.kotlin.BaseDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.BaseDescriptorLoader;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
@@ -370,7 +370,7 @@ public class PackageCodegen {
     @NotNull
     public static String getPackagePartInternalName(@NotNull DeserializedCallableMemberDescriptor callable) {
         FqName packageFqName = ((PackageFragmentDescriptor) callable.getContainingDeclaration()).getFqName();
-        FqName packagePartFqName = packageFqName.child(BaseDescriptorDeserializer.getPackagePartClassName(callable));
+        FqName packagePartFqName = packageFqName.child(BaseDescriptorLoader.getPackagePartClassName(callable));
         return JvmClassName.byFqNameWithoutInnerClasses(packagePartFqName).getInternalName();
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -36,9 +36,9 @@ import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava;
 import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder;
-import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage;
-import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorLoader;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -66,9 +66,9 @@ public class InjectorForJavaDescriptorResolver {
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final DeserializationGlobalContextForJava deserializationGlobalContextForJava;
     private final JavaDescriptorFinder javaDescriptorFinder;
-    private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
+    private final AnnotationDescriptorLoader annotationDescriptorLoader;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
-    private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
+    private final ConstantDescriptorLoader constantDescriptorLoader;
     
     public InjectorForJavaDescriptorResolver(
         @NotNull Project project,
@@ -93,9 +93,9 @@ public class InjectorForJavaDescriptorResolver {
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
         this.memberFilter = org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter.ALWAYS_TRUE;
         this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
-        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
+        this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
-        this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
+        this.constantDescriptorLoader = new ConstantDescriptorLoader();
-        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorDeserializer, constantDescriptorDeserializer, lazyJavaPackageFragmentProvider, memberFilter);
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider, memberFilter);
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
 
         this.javaClassFinder.setProject(project);
@@ -114,18 +114,18 @@ public class InjectorForJavaDescriptorResolver {
         deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
 
-        annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        annotationDescriptorLoader.setClassResolver(javaDescriptorResolver);
-        annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        annotationDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
-        annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        annotationDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
-        annotationDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+        annotationDescriptorLoader.setStorage(descriptorDeserializersStorage);
 
         descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver);
         descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter);
 
-        constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        constantDescriptorLoader.setClassResolver(javaDescriptorResolver);
-        constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        constantDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
-        constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        constantDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
-        constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+        constantDescriptorLoader.setStorage(descriptorDeserializersStorage);
 
         javaClassFinder.initialize();
 

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java

@@ -58,9 +58,9 @@ import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava;
 import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder;
-import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage;
-import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorLoader;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -110,9 +110,9 @@ public class InjectorForLazyResolveWithJava {
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final DeserializationGlobalContextForJava deserializationGlobalContextForJava;
     private final JavaDescriptorFinder javaDescriptorFinder;
-    private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
+    private final AnnotationDescriptorLoader annotationDescriptorLoader;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
-    private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
+    private final ConstantDescriptorLoader constantDescriptorLoader;
     
     public InjectorForLazyResolveWithJava(
         @NotNull Project project,
@@ -161,9 +161,9 @@ public class InjectorForLazyResolveWithJava {
         this.scopeProvider = new ScopeProvider(getResolveSession());
         this.scriptBodyResolver = new ScriptBodyResolver();
         this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
-        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
+        this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
-        this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
+        this.constantDescriptorLoader = new ConstantDescriptorLoader();
-        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorDeserializer, constantDescriptorDeserializer, lazyJavaPackageFragmentProvider, memberFilter);
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider, memberFilter);
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
@@ -244,18 +244,18 @@ public class InjectorForLazyResolveWithJava {
         deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
 
-        annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        annotationDescriptorLoader.setClassResolver(javaDescriptorResolver);
-        annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        annotationDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
-        annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        annotationDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
-        annotationDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+        annotationDescriptorLoader.setStorage(descriptorDeserializersStorage);
 
         descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver);
         descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter);
 
-        constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        constantDescriptorLoader.setClassResolver(javaDescriptorResolver);
-        constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        constantDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
-        constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        constantDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
-        constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+        constantDescriptorLoader.setStorage(descriptorDeserializersStorage);
 
         javaClassFinder.initialize();
 

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -68,9 +68,9 @@ import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava;
 import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder;
-import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader;
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage;
-import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorLoader;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -130,9 +130,9 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final DeserializationGlobalContextForJava deserializationGlobalContextForJava;
     private final JavaDescriptorFinder javaDescriptorFinder;
-    private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
+    private final AnnotationDescriptorLoader annotationDescriptorLoader;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
-    private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
+    private final ConstantDescriptorLoader constantDescriptorLoader;
     
     public InjectorForTopDownAnalyzerForJvm(
         @NotNull Project project,
@@ -192,9 +192,9 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
-        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
+        this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
-        this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
+        this.constantDescriptorLoader = new ConstantDescriptorLoader();
-        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, javaDescriptorFinder, annotationDescriptorDeserializer, constantDescriptorDeserializer, lazyJavaPackageFragmentProvider, memberFilter);
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider, memberFilter);
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(storageManager);
 
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
@@ -325,18 +325,18 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
 
-        annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        annotationDescriptorLoader.setClassResolver(javaDescriptorResolver);
-        annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        annotationDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
-        annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        annotationDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
-        annotationDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+        annotationDescriptorLoader.setStorage(descriptorDeserializersStorage);
 
         descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver);
         descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter);
 
-        constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
+        constantDescriptorLoader.setClassResolver(javaDescriptorResolver);
-        constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        constantDescriptorLoader.setErrorReporter(traceBasedErrorReporter);
-        constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+        constantDescriptorLoader.setKotlinClassFinder(virtualFileFinder);
-        constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage);
+        constantDescriptorLoader.setStorage(descriptorDeserializersStorage);
 
         javaClassFinder.initialize();
 

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorLoader.java

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf;
 import org.jetbrains.jet.descriptors.serialization.NameResolver;
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
-import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
+import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationLoader;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptorImpl;
@@ -49,7 +49,7 @@ import java.util.Map;
 import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind;
 import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature;
 
-public class AnnotationDescriptorDeserializer extends BaseDescriptorDeserializer implements AnnotationDeserializer {
+public class AnnotationDescriptorLoader extends BaseDescriptorLoader implements AnnotationLoader {
     @Inject
     @Override
     public void setStorage(@NotNull DescriptorDeserializersStorage storage) {

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/BaseDescriptorLoader.java

@@ -38,7 +38,7 @@ import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStora
 import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName;
 import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.naiveKotlinFqName;
 
-public abstract class BaseDescriptorDeserializer {
+public abstract class BaseDescriptorLoader {
     protected DependencyClassByQualifiedNameResolver classResolver;
     protected KotlinClassFinder kotlinClassFinder;
     protected ErrorReporter errorReporter;

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorLoader.java

@@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.NameResolver;
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
-import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantDeserializer;
+import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantLoader;
 import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
@@ -31,7 +31,7 @@ import javax.inject.Inject;
 import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind;
 import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature;
 
-public class ConstantDescriptorDeserializer extends BaseDescriptorDeserializer implements ConstantDeserializer {
+public class ConstantDescriptorLoader extends BaseDescriptorLoader implements ConstantLoader {
     @Inject
     @Override
     public void setStorage(@NotNull DescriptorDeserializersStorage storage) {

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializersStorage.java

@@ -108,7 +108,7 @@ public class DescriptorDeserializersStorage {
                         result = new ArrayList<AnnotationDescriptor>();
                         memberAnnotations.put(paramSignature, result);
                     }
-                    return AnnotationDescriptorDeserializer.resolveAnnotation(className, result, classResolver);
+                    return AnnotationDescriptorLoader.resolveAnnotation(className, result, classResolver);
                 }
             }
 
@@ -123,7 +123,7 @@ public class DescriptorDeserializersStorage {
                 @Nullable
                 @Override
                 public KotlinJvmBinaryClass.AnnotationArgumentVisitor visitAnnotation(@NotNull JvmClassName className) {
-                    return AnnotationDescriptorDeserializer.resolveAnnotation(className, result, classResolver);
+                    return AnnotationDescriptorLoader.resolveAnnotation(className, result, classResolver);
                 }
 
                 @Override

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializationGlobalContextForJava.kt

@@ -18,19 +18,14 @@ package org.jetbrains.jet.lang.resolve.kotlin
 
 import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext
 import org.jetbrains.jet.storage.StorageManager
-import org.jetbrains.jet.descriptors.serialization.DescriptorFinder
-import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer
-import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantDeserializer
-import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider
 import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter
 
 public class DeserializationGlobalContextForJava(
         storageManager: StorageManager,
         descriptorFinder: JavaDescriptorFinder,
-        annotationDeserializer: AnnotationDescriptorDeserializer,
+        annotationLoader: AnnotationDescriptorLoader,
-        constantDeserializer: ConstantDescriptorDeserializer,
+        constantLoader: ConstantDescriptorLoader,
         packageFragmentProvider: LazyJavaPackageFragmentProvider,
         memberFilter: MemberFilter
-) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationDeserializer,
+) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader, constantLoader, packageFragmentProvider, memberFilter)
-                                 constantDeserializer, packageFragmentProvider, memberFilter)

core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java

@@ -54,7 +54,7 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {
         DeserializationContext context = new DeserializationContext(
                 storageManager, new BuiltInsDescriptorFinder(storageManager),
                 // TODO: support annotations
-                AnnotationDeserializer.UNSUPPORTED, ConstantDeserializer.UNSUPPORTED, packageFragmentProvider,
+                AnnotationLoader.UNSUPPORTED, ConstantLoader.UNSUPPORTED, packageFragmentProvider,
                 MemberFilter.ALWAYS_TRUE, nameResolver
         );
         members = new DeserializedPackageMemberScope(this, loadPackage(), context);
@@ -122,7 +122,7 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {
 
         public BuiltInsDescriptorFinder(@NotNull StorageManager storageManager) {
             // TODO: support annotations
-            super(storageManager, AnnotationDeserializer.UNSUPPORTED, ConstantDeserializer.UNSUPPORTED, packageFragmentProvider);
+            super(storageManager, AnnotationLoader.UNSUPPORTED, ConstantLoader.UNSUPPORTED, packageFragmentProvider);
 
             classNames = storageManager.createLazyValue(new Function0<Collection<Name>>() {
                 @Override

core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java

@@ -31,12 +31,12 @@ public abstract class AbstractDescriptorFinder implements DescriptorFinder {
 
     public AbstractDescriptorFinder(
             @NotNull StorageManager storageManager,
-            @NotNull AnnotationDeserializer annotationDeserializer,
+            @NotNull AnnotationLoader annotationLoader,
-            @NotNull ConstantDeserializer constantDeserializer,
+            @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

core/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java

@@ -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.*;
-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.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(
+                            return context.getConstantLoader().loadPropertyConstant(
-                                                            (ClassOrPackageFragmentDescriptor) containingDeclaration,
+                                    (ClassOrPackageFragmentDescriptor) containingDeclaration, proto,
-                                                            proto, context.getNameResolver(),
+                                    context.getNameResolver(), AnnotatedCallableKind.PROPERTY);
-                                                            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.getContainingDeclaration(), proto, context.getAnnotationLoader(), context.getNameResolver()
-                context.getAnnotationDeserializer(),
-                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)
+        return Flags.HAS_ANNOTATIONS.get(flags) ? annotationLoader.loadCallableAnnotations(
-               ? annotationDeserializer
+                (ClassOrPackageFragmentDescriptor) containingDeclaration, proto, nameResolver, kind) : Annotations.EMPTY;
-                       .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())
+        return Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags()) ? context.getAnnotationLoader()
-               ? context.getAnnotationDeserializer()
+                       .loadValueParameterAnnotations(classOrPackage, callable, context.getNameResolver(), kind, valueParameter)
-                        .loadValueParameterAnnotations(classOrPackage, callable, context.getNameResolver(), kind, valueParameter)
                : Annotations.EMPTY;
     }
 }

core/serialization/src/org/jetbrains/jet/descriptors/serialization/context/context.kt

@@ -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 annotationLoader: AnnotationLoader,
-        public val constantDeserializer: ConstantDeserializer,
+        public val constantLoader: ConstantLoader,
         public val packageFragmentProvider: PackageFragmentProvider,
         public val memberFilter: MemberFilter
 ) {
     public fun withNameResolver(nameResolver: NameResolver): DeserializationContext {
-        return DeserializationContext(storageManager, descriptorFinder, annotationDeserializer,
+        return DeserializationContext(storageManager, descriptorFinder, annotationLoader,
-                                      constantDeserializer, packageFragmentProvider, memberFilter, nameResolver)
+                                      constantLoader, packageFragmentProvider, memberFilter, nameResolver)
     }
 }
 
@@ -49,13 +48,13 @@ public open class DeserializationGlobalContext(
 public open class DeserializationContext(
         storageManager: StorageManager,
         descriptorFinder: DescriptorFinder,
-        annotationDeserializer: AnnotationDeserializer,
+        annotationLoader: AnnotationLoader,
-        constantDeserializer: ConstantDeserializer,
+        constantLoader: ConstantLoader,
         packageFragmentProvider: PackageFragmentProvider,
         memberFilter: MemberFilter,
         public val nameResolver: NameResolver
-) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationDeserializer,
+) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader,
-                                 constantDeserializer, packageFragmentProvider, memberFilter) {
+                                 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,
+        return DeserializationContextWithTypes(storageManager, descriptorFinder, annotationLoader,
-                                               constantDeserializer, packageFragmentProvider, memberFilter,
+                                               constantLoader, packageFragmentProvider, memberFilter,
                                                nameResolver, containingDeclaration,
                                                typeDeserializer)
     }
@@ -75,15 +74,15 @@ public open class DeserializationContext(
 class DeserializationContextWithTypes(
         storageManager: StorageManager,
         descriptorFinder: DescriptorFinder,
-        annotationDeserializer: AnnotationDeserializer,
+        annotationLoader: AnnotationLoader,
-        constantDeserializer: ConstantDeserializer,
+        constantLoader: ConstantLoader,
         packageFragmentProvider: PackageFragmentProvider,
         memberFilter: MemberFilter,
         nameResolver: NameResolver,
         val containingDeclaration: DeclarationDescriptor,
         val typeDeserializer: TypeDeserializer
-) : DeserializationContext(storageManager, descriptorFinder, annotationDeserializer,
+) : DeserializationContext(storageManager, descriptorFinder, annotationLoader,
-                           constantDeserializer, packageFragmentProvider, memberFilter, nameResolver) {
+                           constantLoader, packageFragmentProvider, memberFilter, nameResolver) {
     val deserializer: DescriptorDeserializer = DescriptorDeserializer(this)
 
     public fun childContext(

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationLoader.java

@@ -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 {
+public interface AnnotationLoader {
-    AnnotationDeserializer UNSUPPORTED = new AnnotationDeserializer() {
+    AnnotationLoader UNSUPPORTED = new AnnotationLoader() {
         @NotNull
         @Override
         public Annotations loadClassAnnotations(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.Class classProto) {

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantLoader.java

@@ -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 {
+public interface ConstantLoader {
-    ConstantDeserializer UNSUPPORTED = new ConstantDeserializer() {
+    ConstantLoader UNSUPPORTED = new ConstantLoader() {
         @Nullable
         @Override
         public CompileTimeConstant<?> loadPropertyConstant(

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java

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

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedSimpleFunctionDescriptor.java

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

idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt

@@ -33,7 +33,7 @@ import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinBinaryClassCache
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope
-import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer
+import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorLoader
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter
 import org.jetbrains.jet.lang.types.error.MissingDependencyErrorClassDescriptor
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils
@@ -41,7 +41,7 @@ import com.intellij.openapi.diagnostic.Logger
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage
-import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer
+import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorLoader
 import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext
@@ -107,26 +107,26 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
         deserializerStorage.setErrorReporter(LOGGING_REPORTER)
     }
 
-    private val annotationDeserializer = AnnotationDescriptorDeserializer();
+    private val annotationLoader = AnnotationDescriptorLoader();
     {
-        annotationDeserializer.setClassResolver {
+        annotationLoader.setClassResolver {
             fqName ->
             classes(fqName.toClassId())
         }
-        annotationDeserializer.setKotlinClassFinder(localClassFinder)
+        annotationLoader.setKotlinClassFinder(localClassFinder)
-        annotationDeserializer.setErrorReporter(LOGGING_REPORTER)
+        annotationLoader.setErrorReporter(LOGGING_REPORTER)
-        annotationDeserializer.setStorage(deserializerStorage)
+        annotationLoader.setStorage(deserializerStorage)
     }
 
-    private val constantDeserializer = ConstantDescriptorDeserializer();
+    private val constantLoader = ConstantDescriptorLoader();
     {
-        constantDeserializer.setClassResolver {
+        constantLoader.setClassResolver {
             fqName ->
             classes(fqName.toClassId())
         }
-        constantDeserializer.setKotlinClassFinder(localClassFinder)
+        constantLoader.setKotlinClassFinder(localClassFinder)
-        constantDeserializer.setErrorReporter(LOGGING_REPORTER)
+        constantLoader.setErrorReporter(LOGGING_REPORTER)
-        constantDeserializer.setStorage(deserializerStorage)
+        constantLoader.setStorage(deserializerStorage)
     }
 
     private val descriptorFinder = object : DescriptorFinder {
@@ -149,8 +149,8 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
         }
     }
 
-    val deserializationContext = DeserializationGlobalContext(storageManager, descriptorFinder, annotationDeserializer,
+    val deserializationContext = DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader,
-                                                              constantDeserializer, packageFragmentProvider, MemberFilter.ALWAYS_TRUE)
+                                                              constantLoader, packageFragmentProvider, MemberFilter.ALWAYS_TRUE)
 
     private fun createDummyPackageFragment(fqName: FqName): MutablePackageFragmentDescriptor {
         return MutablePackageFragmentDescriptor(ErrorUtils.getErrorModule(), fqName)