Refactor: Introduce contexts in deserialization subsystem

Rewrite utilities to Kotlin and move them out of DescriptorDeserializer
Include DescriptorDeserializer into context
Use new context in injectors
Drop Deserializers abstraction

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

@@ -34,7 +34,8 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers;
+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.DescriptorDeserializersStorage;
 import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
@@ -63,7 +64,8 @@ public class InjectorForJavaDescriptorResolver {
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
-    private final DescriptorDeserializers descriptorDeserializers;
+    private final DeserializationGlobalContextForJava deserializationGlobalContextForJava;
+    private final JavaDescriptorFinder javaDescriptorFinder;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
     private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
@@ -90,10 +92,11 @@ public class InjectorForJavaDescriptorResolver {
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
         this.memberFilter = org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter.ALWAYS_TRUE;
-        this.descriptorDeserializers = new DescriptorDeserializers();
+        this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
-        this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
         this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorDeserializer, constantDescriptorDeserializer, lazyJavaPackageFragmentProvider, memberFilter);
+        this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
 
         this.javaClassFinder.setProject(project);
 
@@ -108,15 +111,8 @@ public class InjectorForJavaDescriptorResolver {
         psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
         psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
 
-        deserializedDescriptorResolver.setDeserializers(descriptorDeserializers);
+        deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
-        deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
-        deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
-        deserializedDescriptorResolver.setMemberFilter(memberFilter);
-        deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
-
-        descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);
-        descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer);
 
         annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);

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

@@ -56,7 +56,8 @@ import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers;
+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.DescriptorDeserializersStorage;
 import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
@@ -107,7 +108,8 @@ public class InjectorForLazyResolveWithJava {
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
-    private final DescriptorDeserializers descriptorDeserializers;
+    private final DeserializationGlobalContextForJava deserializationGlobalContextForJava;
+    private final JavaDescriptorFinder javaDescriptorFinder;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
     private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
@@ -158,10 +160,11 @@ public class InjectorForLazyResolveWithJava {
         this.jetImportsFactory = new JetImportsFactory();
         this.scopeProvider = new ScopeProvider(getResolveSession());
         this.scriptBodyResolver = new ScriptBodyResolver();
-        this.descriptorDeserializers = new DescriptorDeserializers();
+        this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
-        this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
         this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorDeserializer, constantDescriptorDeserializer, lazyJavaPackageFragmentProvider, memberFilter);
+        this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
@@ -238,15 +241,8 @@ public class InjectorForLazyResolveWithJava {
 
         scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
 
-        deserializedDescriptorResolver.setDeserializers(descriptorDeserializers);
+        deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
-        deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
-        deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
-        deserializedDescriptorResolver.setMemberFilter(memberFilter);
-        deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
-
-        descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);
-        descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer);
 
         annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);

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

@@ -66,7 +66,8 @@ import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers;
+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.DescriptorDeserializersStorage;
 import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer;
@@ -127,7 +128,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
-    private final DescriptorDeserializers descriptorDeserializers;
+    private final DeserializationGlobalContextForJava deserializationGlobalContextForJava;
+    private final JavaDescriptorFinder javaDescriptorFinder;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final DescriptorDeserializersStorage descriptorDeserializersStorage;
     private final ConstantDescriptorDeserializer constantDescriptorDeserializer;
@@ -189,10 +191,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.typeHierarchyResolver = new TypeHierarchyResolver();
-        this.descriptorDeserializers = new DescriptorDeserializers();
+        this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
-        this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(storageManager);
         this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer();
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, javaDescriptorFinder, annotationDescriptorDeserializer, constantDescriptorDeserializer, lazyJavaPackageFragmentProvider, memberFilter);
+        this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(storageManager);
 
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
@@ -320,15 +323,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver);
         typeHierarchyResolver.setTrace(bindingTrace);
 
-        deserializedDescriptorResolver.setDeserializers(descriptorDeserializers);
+        deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
-        deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
-        deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
-        deserializedDescriptorResolver.setMemberFilter(memberFilter);
-        deserializedDescriptorResolver.setStorageManager(storageManager);
-
-        descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer);
-        descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer);
 
         annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver);
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);

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

@@ -46,7 +46,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
+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 {

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

@@ -31,7 +31,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 
-import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
+import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isClassObject;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isTrait;
 import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature;

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

@@ -28,7 +28,7 @@ import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 
 import javax.inject.Inject;
 
-import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
+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 {

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

@@ -1,52 +0,0 @@
-/*
- * Copyright 2010-2014 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.jet.lang.resolve.kotlin;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
-import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantDeserializer;
-import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers;
-
-import javax.inject.Inject;
-
-public class DescriptorDeserializers implements Deserializers {
-
-    private AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
-    private ConstantDescriptorDeserializer constantDescriptorDeserializer;
-
-    @Inject
-    public void setAnnotationDescriptorDeserializer(AnnotationDescriptorDeserializer annotationDescriptorDeserializer) {
-        this.annotationDescriptorDeserializer = annotationDescriptorDeserializer;
-    }
-
-    @Inject
-    public void setConstantDescriptorDeserializer(ConstantDescriptorDeserializer constantDescriptorDeserializer) {
-        this.constantDescriptorDeserializer = constantDescriptorDeserializer;
-    }
-
-    @NotNull
-    @Override
-    public AnnotationDeserializer getAnnotationDeserializer() {
-        return annotationDescriptorDeserializer;
-    }
-
-    @NotNull
-    @Override
-    public ConstantDeserializer getConstantDeserializer() {
-        return constantDescriptorDeserializer;
-    }
-}

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2014 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.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,
+        constantDeserializer: ConstantDescriptorDeserializer,
+        packageFragmentProvider: LazyJavaPackageFragmentProvider,
+        memberFilter: MemberFilter
+) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationDeserializer,
+                                 constantDeserializer, packageFragmentProvider, memberFilter)

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

@@ -19,76 +19,28 @@ package org.jetbrains.jet.lang.resolve.kotlin;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.ClassData;
-import org.jetbrains.jet.descriptors.serialization.ClassId;
-import org.jetbrains.jet.descriptors.serialization.DescriptorFinder;
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
-import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.storage.StorageManager;
 
 import javax.inject.Inject;
-import java.util.Collection;
 
-import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName;
 import static org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader.Kind.CLASS;
 import static org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader.Kind.PACKAGE_FACADE;
 
 public final class DeserializedDescriptorResolver {
-    private DescriptorDeserializers deserializers;
-
-    private MemberFilter memberFilter;
-
-    private StorageManager storageManager;
-
-    private JavaPackageFragmentProvider javaPackageFragmentProvider;
-
-    private JavaDescriptorResolver javaDescriptorResolver;
+    private DeserializationGlobalContextForJava context;
 
     private ErrorReporter errorReporter;
 
-    @NotNull
-    private final DescriptorFinder javaDescriptorFinder = new DescriptorFinder() {
-        @Nullable
-        @Override
-        public ClassDescriptor findClass(@NotNull ClassId classId) {
-            return javaDescriptorResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName()));
-        }
-
-        @NotNull
-        @Override
-        public Collection<Name> getClassNames(@NotNull FqName packageName) {
-            return javaPackageFragmentProvider.getClassNamesInPackage(packageName);
-        }
-    };
-
     @Inject
-    public void setDeserializers(DescriptorDeserializers deserializers) {
-        this.deserializers = deserializers;
-    }
-
-    @Inject
-    public void setMemberFilter(MemberFilter memberFilter) {
-        this.memberFilter = memberFilter;
-    }
-
-    @Inject
-    public void setJavaPackageFragmentProvider(JavaPackageFragmentProvider javaPackageFragmentProvider) {
-        this.javaPackageFragmentProvider = javaPackageFragmentProvider;
-    }
-
-    @Inject
-    public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) {
-        this.javaDescriptorResolver = javaDescriptorResolver;
+    public void setContext(DeserializationGlobalContextForJava context) {
+        this.context = context;
     }
 
     @Inject
@@ -96,18 +48,12 @@ public final class DeserializedDescriptorResolver {
         this.errorReporter = errorReporter;
     }
 
-    @Inject
-    public void setStorageManager(StorageManager storageManager) {
-        this.storageManager = storageManager;
-    }
-
     @Nullable
     public ClassDescriptor resolveClass(@NotNull KotlinJvmBinaryClass kotlinClass) {
         String[] data = readData(kotlinClass, CLASS);
         if (data != null) {
             ClassData classData = JavaProtoBufUtil.readClassDataFrom(data);
-            return new DeserializedClassDescriptor(storageManager, deserializers, javaDescriptorFinder,
-                                                   javaPackageFragmentProvider, classData.getNameResolver(), classData.getClassProto());
+            return new DeserializedClassDescriptor(context, classData);
         }
         return null;
     }
@@ -116,8 +62,7 @@ public final class DeserializedDescriptorResolver {
     public JetScope createKotlinPackageScope(@NotNull PackageFragmentDescriptor descriptor, @NotNull KotlinJvmBinaryClass kotlinClass) {
         String[] data = readData(kotlinClass, PACKAGE_FACADE);
         if (data != null) {
-            return new DeserializedPackageMemberScope(storageManager, descriptor, deserializers,
-                                                      memberFilter, javaDescriptorFinder, JavaProtoBufUtil.readPackageDataFrom(data));
+            return new DeserializedPackageMemberScope(descriptor, JavaProtoBufUtil.readPackageDataFrom(data), context);
         }
         return null;
     }

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

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2014 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.jet.lang.resolve.kotlin
+
+import org.jetbrains.annotations.Nullable
+import org.jetbrains.jet.descriptors.serialization.ClassId
+import org.jetbrains.jet.descriptors.serialization.DescriptorFinder
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider
+import org.jetbrains.jet.lang.resolve.name.FqName
+import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver
+import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName
+
+public class JavaDescriptorFinder(
+        private val javaDescriptorResolver: DependencyClassByQualifiedNameResolver,
+        private val javaPackageFragmentProvider: JavaPackageFragmentProvider
+) : DescriptorFinder {
+
+    override fun findClass(classId: ClassId): ClassDescriptor? {
+        return javaDescriptorResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName()))
+    }
+
+    override fun getClassNames(packageName: FqName): Collection<Name> {
+        return javaPackageFragmentProvider.getClassNamesInPackage(packageName)
+    }
+}

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

@@ -20,9 +20,8 @@ import kotlin.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.*;
-import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
-import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers;
-import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter;
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext;
+import org.jetbrains.jet.descriptors.serialization.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptorImpl;
@@ -52,9 +51,13 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {
 
         packageFragmentProvider = new BuiltinsPackageFragmentProvider();
 
-        // TODO: support annotations
-        members = new DeserializedPackageMemberScope(storageManager, this, Deserializers.UNSUPPORTED, MemberFilter.ALWAYS_TRUE,
-                                                     new BuiltInsDescriptorFinder(storageManager), loadPackage(), nameResolver);
+        DeserializationContext context = new DeserializationContext(
+                storageManager, new BuiltInsDescriptorFinder(storageManager),
+                // TODO: support annotations
+                AnnotationDeserializer.UNSUPPORTED, ConstantDeserializer.UNSUPPORTED, packageFragmentProvider,
+                MemberFilter.ALWAYS_TRUE, nameResolver
+        );
+        members = new DeserializedPackageMemberScope(this, loadPackage(), context);
     }
 
     @NotNull
@@ -119,7 +122,7 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {
 
         public BuiltInsDescriptorFinder(@NotNull StorageManager storageManager) {
             // TODO: support annotations
-            super(storageManager, Deserializers.UNSUPPORTED, packageFragmentProvider);
+            super(storageManager, AnnotationDeserializer.UNSUPPORTED, ConstantDeserializer.UNSUPPORTED, packageFragmentProvider);
 
             classNames = storageManager.createLazyValue(new Function0<Collection<Name>>() {
                 @Override

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

@@ -19,8 +19,8 @@ package org.jetbrains.jet.descriptors.serialization;
 import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers;
-import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext;
+import org.jetbrains.jet.descriptors.serialization.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
 import org.jetbrains.jet.storage.MemoizedFunctionToNullable;
@@ -28,26 +28,21 @@ import org.jetbrains.jet.storage.StorageManager;
 
 public abstract class AbstractDescriptorFinder implements DescriptorFinder {
     private final MemoizedFunctionToNullable<ClassId, ClassDescriptor> findClass;
-    private final Deserializers deserializers;
 
     public AbstractDescriptorFinder(
-            @NotNull final StorageManager storageManager,
-            @NotNull Deserializers deserializers,
-            @NotNull final PackageFragmentProvider packageFragmentProvider
+            @NotNull StorageManager storageManager,
+            @NotNull AnnotationDeserializer annotationDeserializer,
+            @NotNull ConstantDeserializer constantDeserializer,
+            @NotNull PackageFragmentProvider packageFragmentProvider
     ) {
-        this.deserializers = deserializers;
-
+        final DeserializationGlobalContext deserializationGlobalContext =
+                new DeserializationGlobalContext(storageManager, this, annotationDeserializer, constantDeserializer,
+                                                 packageFragmentProvider, MemberFilter.ALWAYS_TRUE);
         this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function1<ClassId, ClassDescriptor>() {
             @Override
             public ClassDescriptor invoke(ClassId classId) {
                 ClassData classData = getClassData(classId);
-                if (classData == null) {
-                    return null;
-                }
-
-                AbstractDescriptorFinder _this = AbstractDescriptorFinder.this;
-                return new DeserializedClassDescriptor(storageManager, _this.deserializers, _this, packageFragmentProvider,
-                                                classData.getNameResolver(), classData.getClassProto());
+                return classData == null ? null : new DeserializedClassDescriptor(deserializationGlobalContext, classData);
             }
         });
     }

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

@@ -19,15 +19,20 @@ package org.jetbrains.jet.descriptors.serialization;
 import kotlin.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.descriptors.serialization.descriptors.*;
+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.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
-import org.jetbrains.jet.lang.descriptors.impl.*;
+import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.PropertyGetterDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.PropertySetterDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.DescriptorFactory;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
-import org.jetbrains.jet.lang.types.Variance;
-import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -35,86 +40,16 @@ import java.util.List;
 
 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.TypeDeserializer.TypeParameterResolver.NONE;
-import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
+import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.*;
+
+import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind;
 
 public class DescriptorDeserializer {
 
-    @NotNull
-    public static DescriptorDeserializer create(
-            @NotNull StorageManager storageManager,
-            @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull NameResolver nameResolver,
-            @NotNull DescriptorFinder descriptorFinder,
-            @NotNull Deserializers deserializers
-    ) {
-        return new DescriptorDeserializer(storageManager,
-                new TypeDeserializer(storageManager, null, nameResolver, descriptorFinder,
-                                     "Deserializer for " + containingDeclaration.getName(), NONE),
-                containingDeclaration, nameResolver, deserializers);
-    }
+    private final DeserializationContextWithTypes context;
 
-    @NotNull
-    public static DescriptorDeserializer create(
-            @NotNull StorageManager storageManager,
-            @NotNull TypeDeserializer typeDeserializer,
-            @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull NameResolver nameResolver,
-            @NotNull Deserializers deserializers
-    ) {
-        return new DescriptorDeserializer(storageManager, typeDeserializer, containingDeclaration, nameResolver, deserializers);
-    }
-
-    private final DeclarationDescriptor containingDeclaration;
-    private final NameResolver nameResolver;
-    private final TypeDeserializer typeDeserializer;
-    private final Deserializers deserializers;
-
-    private final StorageManager storageManager;
-
-    private DescriptorDeserializer(
-            @NotNull StorageManager storageManager,
-            @NotNull TypeDeserializer typeDeserializer,
-            @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull NameResolver nameResolver,
-            @NotNull Deserializers deserializers
-    ) {
-        this.storageManager = storageManager;
-        this.typeDeserializer = typeDeserializer;
-        this.containingDeclaration = containingDeclaration;
-        this.nameResolver = nameResolver;
-        this.deserializers = deserializers;
-    }
-
-    @NotNull
-    public TypeDeserializer getTypeDeserializer() {
-        return typeDeserializer;
-    }
-
-    @NotNull
-    public NameResolver getNameResolver() {
-        return nameResolver;
-    }
-
-    @NotNull
-    public DescriptorDeserializer createChildDeserializer(
-            @NotNull DeclarationDescriptor descriptor,
-            @NotNull final List<TypeParameter> typeParameterProtos,
-            @NotNull final List<TypeParameterDescriptor> typeParameters
-    ) {
-        TypeDeserializer childTypeDeserializer = new TypeDeserializer(
-                storageManager,
-                typeDeserializer, "Child deserializer for " + descriptor.getName(),
-                new TypeDeserializer.TypeParameterResolver() {
-                    @NotNull
-                    @Override
-                    public List<DeserializedTypeParameterDescriptor> getTypeParameters(@NotNull TypeDeserializer typeDeserializer) {
-                        List<DeserializedTypeParameterDescriptor> descriptors = typeParameters(typeParameterProtos, typeDeserializer);
-                        typeParameters.addAll(descriptors);
-                        return descriptors;
-                    }
-                });
-        return create(storageManager, childTypeDeserializer, descriptor, nameResolver, deserializers);
+    public DescriptorDeserializer(@NotNull DeserializationContextWithTypes context) {
+        this.context = context;
     }
 
     @NotNull
@@ -137,25 +72,25 @@ public class DescriptorDeserializer {
         final int flags = proto.getFlags();
 
         DeserializedPropertyDescriptor property = new DeserializedPropertyDescriptor(
-                containingDeclaration,
+                context.getContainingDeclaration(),
                 null,
                 getAnnotations(proto, flags, AnnotatedCallableKind.PROPERTY),
                 modality(Flags.MODALITY.get(flags)),
                 visibility(Flags.VISIBILITY.get(flags)),
                 Flags.CALLABLE_KIND.get(flags) == Callable.CallableKind.VAR,
-                nameResolver.getName(proto.getName()),
-                memberKind(Flags.MEMBER_KIND.get(flags)),
+                context.getNameResolver().getName(proto.getName()),
+                SerializationPackage.memberKind(Flags.MEMBER_KIND.get(flags)),
                 proto,
-                nameResolver
+                context.getNameResolver()
         );
 
         List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(proto.getTypeParameterCount());
-        DescriptorDeserializer local = createChildDeserializer(property, proto.getTypeParameterList(), typeParameters);
+        DeserializationContextWithTypes local = context.childContext(property, proto.getTypeParameterList(), typeParameters);
         property.setType(
-                local.typeDeserializer.type(proto.getReturnType()),
+                local.getTypeDeserializer().type(proto.getReturnType()),
                 typeParameters,
                 getExpectedThisObject(),
-                local.typeDeserializer.typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null)
+                local.getTypeDeserializer().typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null)
         );
 
         PropertyGetterDescriptorImpl getter = null;
@@ -168,7 +103,8 @@ public class DescriptorDeserializer {
                 getter = new PropertyGetterDescriptorImpl(property,
                                                           getAnnotations(proto, getterFlags, AnnotatedCallableKind.PROPERTY_GETTER),
                                                           modality(Flags.MODALITY.get(getterFlags)),
-                                                          visibility(Flags.VISIBILITY.get(getterFlags)), isNotDefault, !isNotDefault,
+                                                          visibility(Flags.VISIBILITY.get(getterFlags)),
+                                                          isNotDefault, !isNotDefault,
                                                           property.getKind(), null);
             }
             else {
@@ -184,11 +120,13 @@ public class DescriptorDeserializer {
                 setter = new PropertySetterDescriptorImpl(property,
                                                           getAnnotations(proto, setterFlags, AnnotatedCallableKind.PROPERTY_SETTER),
                                                           modality(Flags.MODALITY.get(setterFlags)),
-                                                          visibility(Flags.VISIBILITY.get(setterFlags)), isNotDefault, !isNotDefault,
+                                                          visibility(Flags.VISIBILITY.get(setterFlags)), isNotDefault,
+                                                          !isNotDefault,
                                                           property.getKind(), null);
-                DescriptorDeserializer setterLocal = local.createChildDeserializer(setter, Collections.<TypeParameter>emptyList(),
-                                                                                   Collections.<TypeParameterDescriptor>emptyList());
-                List<ValueParameterDescriptor> valueParameters = setterLocal.valueParameters(proto, AnnotatedCallableKind.PROPERTY_SETTER);
+                DeserializationContextWithTypes setterLocal = local.childContext(setter, Collections.<TypeParameter>emptyList(),
+                                                                                 Collections.<TypeParameterDescriptor>emptyList());
+                List<ValueParameterDescriptor> valueParameters
+                        = setterLocal.getDeserializer().valueParameters(proto, AnnotatedCallableKind.PROPERTY_SETTER);
                 assert valueParameters.size() == 1 : "Property setter should have a single value parameter: " + setter;
                 setter.initialize(valueParameters.get(0));
             }
@@ -199,15 +137,16 @@ public class DescriptorDeserializer {
 
         if (Flags.HAS_CONSTANT.get(flags)) {
             property.setCompileTimeInitializer(
-                    storageManager.createNullableLazyValue(new Function0<CompileTimeConstant<?>>() {
+                    context.getStorageManager().createNullableLazyValue(new Function0<CompileTimeConstant<?>>() {
                         @Nullable
                         @Override
                         public CompileTimeConstant<?> invoke() {
+                            DeclarationDescriptor containingDeclaration = context.getContainingDeclaration();
                             assert containingDeclaration instanceof ClassOrPackageFragmentDescriptor
                                     : "Only members in classes or package fragments should be serialized: " + containingDeclaration;
-                            return deserializers.getConstantDeserializer().loadPropertyConstant(
+                            return context.getConstantDeserializer().loadPropertyConstant(
                                                             (ClassOrPackageFragmentDescriptor) containingDeclaration,
-                                                            proto, nameResolver,
+                                                            proto, context.getNameResolver(),
                                                             AnnotatedCallableKind.PROPERTY);
                         }
                     })
@@ -223,18 +162,18 @@ public class DescriptorDeserializer {
     private CallableMemberDescriptor loadFunction(@NotNull Callable proto) {
         int flags = proto.getFlags();
         DeserializedSimpleFunctionDescriptor function = DeserializedSimpleFunctionDescriptor.create(
-                containingDeclaration, proto,
-                deserializers,
-                nameResolver
+                context.getContainingDeclaration(), proto,
+                context.getAnnotationDeserializer(),
+                context.getNameResolver()
         );
         List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(proto.getTypeParameterCount());
-        DescriptorDeserializer local = createChildDeserializer(function, proto.getTypeParameterList(), typeParameters);
+        DeserializationContextWithTypes local = context.childContext(function, proto.getTypeParameterList(), typeParameters);
         function.initialize(
-                local.typeDeserializer.typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null),
+                local.getTypeDeserializer().typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null),
                 getExpectedThisObject(),
                 typeParameters,
-                local.valueParameters(proto, AnnotatedCallableKind.FUNCTION),
-                local.typeDeserializer.type(proto.getReturnType()),
+                local.getDeserializer().valueParameters(proto, AnnotatedCallableKind.FUNCTION),
+                local.getTypeDeserializer().type(proto.getReturnType()),
                 modality(Flags.MODALITY.get(flags)),
                 visibility(Flags.VISIBILITY.get(flags))
         );
@@ -243,33 +182,34 @@ public class DescriptorDeserializer {
 
     @Nullable
     private ReceiverParameterDescriptor getExpectedThisObject() {
+        DeclarationDescriptor containingDeclaration = context.getContainingDeclaration();
         return containingDeclaration instanceof ClassDescriptor
                ? ((ClassDescriptor) containingDeclaration).getThisAsReceiverParameter() : null;
     }
 
     @NotNull
     private CallableMemberDescriptor loadConstructor(@NotNull Callable proto) {
-        ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration;
+        ClassDescriptor classDescriptor = (ClassDescriptor) context.getContainingDeclaration();
         ConstructorDescriptorImpl descriptor = ConstructorDescriptorImpl.create(
                 classDescriptor,
                 getAnnotations(proto, proto.getFlags(), AnnotatedCallableKind.FUNCTION),
                 // TODO: primary
                 true);
         List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(proto.getTypeParameterCount());
-        DescriptorDeserializer local = createChildDeserializer(descriptor, Collections.<TypeParameter>emptyList(), typeParameters);
+        DeserializationContextWithTypes local = context.childContext(descriptor, Collections.<TypeParameter>emptyList(), typeParameters);
         descriptor.initialize(
                 classDescriptor.getTypeConstructor().getParameters(),
-                local.valueParameters(proto, AnnotatedCallableKind.FUNCTION),
+                local.getDeserializer().valueParameters(proto, AnnotatedCallableKind.FUNCTION),
                 visibility(Flags.VISIBILITY.get(proto.getFlags())),
                 DescriptorUtils.isConstructorOfStaticNestedClass(descriptor)
         );
-        descriptor.setReturnType(local.typeDeserializer.type(proto.getReturnType()));
+        descriptor.setReturnType(local.getTypeDeserializer().type(proto.getReturnType()));
         return descriptor;
     }
 
     @NotNull
     private Annotations getAnnotations(@NotNull Callable proto, int flags, @NotNull AnnotatedCallableKind kind) {
-        return getAnnotations(containingDeclaration, proto, flags, kind, deserializers.getAnnotationDeserializer(), nameResolver);
+        return getAnnotations(context.getContainingDeclaration(), proto, flags, kind, context.getAnnotationDeserializer(), context.getNameResolver());
     }
 
     public static Annotations getAnnotations(
@@ -288,71 +228,6 @@ public class DescriptorDeserializer {
                : Annotations.EMPTY;
     }
 
-    public static CallableMemberDescriptor.Kind memberKind(Callable.MemberKind memberKind) {
-        switch (memberKind) {
-            case DECLARATION:
-                return CallableMemberDescriptor.Kind.DECLARATION;
-            case FAKE_OVERRIDE:
-                return CallableMemberDescriptor.Kind.FAKE_OVERRIDE;
-            case DELEGATION:
-                return CallableMemberDescriptor.Kind.DELEGATION;
-            case SYNTHESIZED:
-                return CallableMemberDescriptor.Kind.SYNTHESIZED;
-        }
-        throw new IllegalArgumentException("Unknown member kind: " + memberKind);
-    }
-
-    @NotNull
-    public static Modality modality(@NotNull ProtoBuf.Modality modality) {
-        switch (modality) {
-            case FINAL:
-                return Modality.FINAL;
-            case OPEN:
-                return Modality.OPEN;
-            case ABSTRACT:
-                return Modality.ABSTRACT;
-        }
-        throw new IllegalArgumentException("Unknown modality: " + modality);
-    }
-
-    @NotNull
-    public static Visibility visibility(@NotNull ProtoBuf.Visibility visibility) {
-        switch (visibility) {
-            case INTERNAL:
-                return Visibilities.INTERNAL;
-            case PRIVATE:
-                return Visibilities.PRIVATE;
-            case PROTECTED:
-                return Visibilities.PROTECTED;
-            case PUBLIC:
-                return Visibilities.PUBLIC;
-            case EXTRA:
-                throw new UnsupportedOperationException("Extra visibilities are not supported yet"); // TODO
-        }
-        throw new IllegalArgumentException("Unknown visibility: " + visibility);
-    }
-
-    @NotNull
-    public static ClassKind classKind(@NotNull ProtoBuf.Class.Kind kind) {
-        switch (kind) {
-            case CLASS:
-                return ClassKind.CLASS;
-            case TRAIT:
-                return ClassKind.TRAIT;
-            case ENUM_CLASS:
-                return ClassKind.ENUM_CLASS;
-            case ENUM_ENTRY:
-                return ClassKind.ENUM_ENTRY;
-            case ANNOTATION_CLASS:
-                return ClassKind.ANNOTATION_CLASS;
-            case OBJECT:
-                return ClassKind.OBJECT;
-            case CLASS_OBJECT:
-                return ClassKind.CLASS_OBJECT;
-        }
-        throw new IllegalArgumentException("Unknown class kind: " + kind);
-    }
-
     @NotNull
     public List<DeserializedTypeParameterDescriptor> typeParameters(
             @NotNull List<TypeParameter> protos,
@@ -362,11 +237,11 @@ public class DescriptorDeserializer {
         for (int i = 0; i < protos.size(); i++) {
             TypeParameter proto = protos.get(i);
             DeserializedTypeParameterDescriptor descriptor = new DeserializedTypeParameterDescriptor(
-                    storageManager,
+                    context.getStorageManager(),
                     typeDeserializer,
                     proto,
-                    containingDeclaration,
-                    nameResolver.getName(proto.getName()),
+                    context.getContainingDeclaration(),
+                    context.getNameResolver().getName(proto.getName()),
                     variance(proto.getVariance()),
                     proto.getReified(),
                     i
@@ -376,21 +251,9 @@ public class DescriptorDeserializer {
         return result;
     }
 
-    private static Variance variance(TypeParameter.Variance proto) {
-        switch (proto) {
-            case IN:
-                return Variance.IN_VARIANCE;
-            case OUT:
-                return Variance.OUT_VARIANCE;
-            case INV:
-                return Variance.INVARIANT;
-        }
-        throw new IllegalStateException("Unknown projection: " + proto);
-    }
-
     @NotNull
     private List<ValueParameterDescriptor> valueParameters(@NotNull Callable callable, @NotNull AnnotatedCallableKind kind) {
-        DeclarationDescriptor containerOfCallable = containingDeclaration.getContainingDeclaration();
+        DeclarationDescriptor containerOfCallable = context.getContainingDeclaration().getContainingDeclaration();
         assert containerOfCallable instanceof ClassOrPackageFragmentDescriptor
                 : "Only members in classes or package fragments should be serialized: " + containerOfCallable;
         ClassOrPackageFragmentDescriptor classOrPackage = (ClassOrPackageFragmentDescriptor) containerOfCallable;
@@ -400,14 +263,14 @@ public class DescriptorDeserializer {
         for (int i = 0; i < protos.size(); i++) {
             Callable.ValueParameter proto = protos.get(i);
             result.add(new ValueParameterDescriptorImpl(
-                    containingDeclaration,
+                    context.getContainingDeclaration(),
                     null,
                     i,
                     getAnnotations(classOrPackage, callable, kind, proto),
-                    nameResolver.getName(proto.getName()),
-                    typeDeserializer.type(proto.getType()),
+                    context.getNameResolver().getName(proto.getName()),
+                    context.getTypeDeserializer().type(proto.getType()),
                     Flags.DECLARES_DEFAULT_VALUE.get(proto.getFlags()),
-                    typeDeserializer.typeOrNull(proto.hasVarargElementType() ? proto.getVarargElementType() : null))
+                    context.getTypeDeserializer().typeOrNull(proto.hasVarargElementType() ? proto.getVarargElementType() : null))
             );
         }
         return result;
@@ -421,7 +284,8 @@ public class DescriptorDeserializer {
             @NotNull Callable.ValueParameter valueParameter
     ) {
         return Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags())
-               ? deserializers.getAnnotationDeserializer().loadValueParameterAnnotations(classOrPackage, callable, nameResolver, kind, valueParameter)
+               ? context.getAnnotationDeserializer()
+                        .loadValueParameterAnnotations(classOrPackage, callable, context.getNameResolver(), kind, valueParameter)
                : Annotations.EMPTY;
     }
 }

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

@@ -21,6 +21,8 @@ import kotlin.Function0;
 import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.ReadOnly;
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
@@ -30,12 +32,13 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.storage.MemoizedFunctionToNullable;
 import org.jetbrains.jet.storage.NotNullLazyValue;
-import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.variance;
+
 public class TypeDeserializer {
 
     public interface TypeParameterResolver {
@@ -48,11 +51,10 @@ public class TypeDeserializer {
         };
 
         @NotNull
+        @ReadOnly
         List<DeserializedTypeParameterDescriptor> getTypeParameters(@NotNull TypeDeserializer typeDeserializer);
     }
 
-    private final NameResolver nameResolver;
-    private final DescriptorFinder descriptorFinder;
     private final TypeDeserializer parent;
 
     // never written to after constructor returns
@@ -62,45 +64,29 @@ public class TypeDeserializer {
 
     private final String debugName;
 
-    private final StorageManager storageManager;
+    private final DeserializationContext context;
 
     public TypeDeserializer(
-            @NotNull StorageManager storageManager,
-            @NotNull TypeDeserializer parent,
-            @NotNull String debugName,
-            @NotNull TypeParameterResolver typeParameterResolver
-    ) {
-        this(storageManager, parent, parent.nameResolver, parent.descriptorFinder, debugName, typeParameterResolver);
-    }
-
-    public TypeDeserializer(
-            @NotNull StorageManager storageManager,
+            @NotNull DeserializationContext context,
             @Nullable TypeDeserializer parent,
-            @NotNull NameResolver nameResolver,
-            @NotNull DescriptorFinder descriptorFinder,
             @NotNull String debugName,
             @NotNull TypeParameterResolver typeParameterResolver
     ) {
-        this.storageManager = storageManager;
         this.parent = parent;
-        this.nameResolver = nameResolver;
-        this.descriptorFinder = descriptorFinder;
         this.debugName = debugName + (parent == null ? "" : ". Child of " + parent.debugName);
+        this.context = context;
 
         for (DeserializedTypeParameterDescriptor typeParameterDescriptor : typeParameterResolver.getTypeParameters(this)) {
             typeParameterDescriptors.put(typeParameterDescriptor.getProtoId(), typeParameterDescriptor);
         }
 
-        this.classDescriptors = storageManager.createMemoizedFunctionWithNullableValues(new Function1<Integer, ClassDescriptor>() {
-            @Override
-            public ClassDescriptor invoke(Integer fqNameIndex) {
-                return computeClassDescriptor(fqNameIndex);
-            }
-        });
-    }
-
-    /* package */ DescriptorFinder getDescriptorFinder() {
-        return descriptorFinder;
+        this.classDescriptors = context.getStorageManager().createMemoizedFunctionWithNullableValues(
+                new Function1<Integer, ClassDescriptor>() {
+                    @Override
+                    public ClassDescriptor invoke(Integer fqNameIndex) {
+                        return computeClassDescriptor(fqNameIndex);
+                    }
+                });
     }
 
     @Nullable
@@ -122,7 +108,7 @@ public class TypeDeserializer {
         TypeConstructor typeConstructor = typeConstructor(constructorProto);
         if (typeConstructor == null) {
             String message = constructorProto.getKind() == ProtoBuf.Type.Constructor.Kind.CLASS
-                             ? nameResolver.getClassId(id).asSingleFqName().asString()
+                             ? context.getNameResolver().getClassId(id).asSingleFqName().asString()
                              : "Unknown type parameter " + id;
             typeConstructor = ErrorUtils.createErrorType(message).getConstructor();
         }
@@ -159,8 +145,8 @@ public class TypeDeserializer {
 
     @Nullable
     private ClassDescriptor computeClassDescriptor(int fqNameIndex) {
-        ClassId classId = nameResolver.getClassId(fqNameIndex);
-        return descriptorFinder.findClass(classId);
+        ClassId classId = context.getNameResolver().getClassId(fqNameIndex);
+        return context.getDescriptorFinder().findClass(classId);
     }
 
     private List<TypeProjection> typeArguments(List<ProtoBuf.Type.Argument> protos) {
@@ -172,22 +158,7 @@ public class TypeDeserializer {
     }
 
     private TypeProjection typeProjection(ProtoBuf.Type.Argument proto) {
-        return new TypeProjectionImpl(
-                variance(proto.getProjection()),
-                type(proto.getType())
-        );
-    }
-
-    private static Variance variance(ProtoBuf.Type.Argument.Projection proto) {
-        switch (proto) {
-            case IN:
-                return Variance.IN_VARIANCE;
-            case OUT:
-                return Variance.OUT_VARIANCE;
-            case INV:
-                return Variance.INVARIANT;
-        }
-        throw new IllegalStateException("Unknown projection: " + proto);
+        return new TypeProjectionImpl(variance(proto.getProjection()), type(proto.getType()));
     }
 
     @NotNull
@@ -215,13 +186,13 @@ public class TypeDeserializer {
             this.typeProto = proto;
             this.arguments = typeArguments(proto.getArgumentList());
 
-            this.constructor = storageManager.createLazyValue(new Function0<TypeConstructor>() {
+            this.constructor = context.getStorageManager().createLazyValue(new Function0<TypeConstructor>() {
                 @Override
                 public TypeConstructor invoke() {
                     return typeConstructor(typeProto);
                 }
             });
-            this.memberScope = storageManager.createLazyValue(new Function0<JetScope>() {
+            this.memberScope = context.getStorageManager().createLazyValue(new Function0<JetScope>() {
                 @Override
                 public JetScope invoke() {
                     return computeMemberScope();

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

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2010-2014 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.jet.descriptors.serialization.context
+
+import org.jetbrains.jet.storage.StorageManager
+import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer
+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
+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
+
+public open class DeserializationGlobalContext(
+        public val storageManager: StorageManager,
+        public val descriptorFinder: DescriptorFinder,
+        public val annotationDeserializer: AnnotationDeserializer,
+        public val constantDeserializer: ConstantDeserializer,
+        public val packageFragmentProvider: PackageFragmentProvider,
+        public val memberFilter: MemberFilter
+) {
+    public fun withNameResolver(nameResolver: NameResolver): DeserializationContext {
+        return DeserializationContext(storageManager, descriptorFinder, annotationDeserializer,
+                                      constantDeserializer, packageFragmentProvider, memberFilter, nameResolver)
+    }
+}
+
+
+public open class DeserializationContext(
+        storageManager: StorageManager,
+        descriptorFinder: DescriptorFinder,
+        annotationDeserializer: AnnotationDeserializer,
+        constantDeserializer: ConstantDeserializer,
+        packageFragmentProvider: PackageFragmentProvider,
+        memberFilter: MemberFilter,
+        public val nameResolver: NameResolver
+) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationDeserializer,
+                                 constantDeserializer, packageFragmentProvider, memberFilter) {
+    fun withTypes(containingDeclaration: DeclarationDescriptor): DeserializationContextWithTypes {
+        val typeDeserializer = TypeDeserializer(this, null, "Deserializer for ${containingDeclaration.getName()}",
+                                                TypeDeserializer.TypeParameterResolver.NONE)
+        return withTypes(containingDeclaration, typeDeserializer)
+    }
+
+    fun withTypes(containingDeclaration: DeclarationDescriptor, typeDeserializer: TypeDeserializer): DeserializationContextWithTypes {
+        return DeserializationContextWithTypes(storageManager, descriptorFinder, annotationDeserializer,
+                                               constantDeserializer, packageFragmentProvider, memberFilter,
+                                               nameResolver, containingDeclaration,
+                                               typeDeserializer)
+    }
+
+}
+
+
+class DeserializationContextWithTypes(
+        storageManager: StorageManager,
+        descriptorFinder: DescriptorFinder,
+        annotationDeserializer: AnnotationDeserializer,
+        constantDeserializer: ConstantDeserializer,
+        packageFragmentProvider: PackageFragmentProvider,
+        memberFilter: MemberFilter,
+        nameResolver: NameResolver,
+        val containingDeclaration: DeclarationDescriptor,
+        val typeDeserializer: TypeDeserializer
+) : DeserializationContext(storageManager, descriptorFinder, annotationDeserializer,
+                           constantDeserializer, packageFragmentProvider, memberFilter, nameResolver) {
+    val deserializer: DescriptorDeserializer = DescriptorDeserializer(this)
+
+    public fun childContext(
+            descriptor: DeclarationDescriptor,
+            typeParameterProtos: List<TypeParameter>,
+            typeParameters: MutableList<TypeParameterDescriptor>
+    ): DeserializationContextWithTypes {
+        val childTypeParameterResolver = object : TypeDeserializer.TypeParameterResolver {
+            override fun getTypeParameters(typeDeserializer: TypeDeserializer): List<DeserializedTypeParameterDescriptor> {
+                val descriptors = deserializer.typeParameters(typeParameterProtos, typeDeserializer)
+                typeParameters.addAll(descriptors)
+                return descriptors
+            }
+        }
+        val childTypeDeserializer = TypeDeserializer(this, typeDeserializer, "Child deserializer for " + descriptor.getName(),
+                                                     childTypeParameterResolver)
+        return withTypes(descriptor, childTypeDeserializer)
+    }
+
+}

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

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2014 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.jet.descriptors.serialization.descriptors;
+
+public enum AnnotatedCallableKind {
+    FUNCTION,
+    PROPERTY,
+    PROPERTY_GETTER,
+    PROPERTY_SETTER
+}

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

@@ -23,8 +23,6 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 
-import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
-
 public interface AnnotationDeserializer {
     AnnotationDeserializer UNSUPPORTED = new AnnotationDeserializer() {
         @NotNull

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

@@ -23,8 +23,6 @@ import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
 import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 
-import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind;
-
 public interface ConstantDeserializer {
     ConstantDeserializer UNSUPPORTED = new ConstantDeserializer() {
         @Nullable

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

@@ -22,6 +22,9 @@ import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.*;
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext;
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes;
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.AbstractClassDescriptor;
@@ -45,21 +48,17 @@ import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.*;
 
-import static org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver.NONE;
+import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.*;
 import static org.jetbrains.jet.lang.resolve.name.SpecialNames.getClassObjectName;
 
 public class DeserializedClassDescriptor extends AbstractClassDescriptor implements ClassDescriptor {
 
     private final ClassId classId;
     private final ProtoBuf.Class classProto;
-    private final StorageManager storageManager;
-    private final TypeDeserializer typeDeserializer;
-    private final DescriptorDeserializer deserializer;
     private final DeserializedMemberScope memberScope;
 
     private final NullableLazyValue<ConstructorDescriptor> primaryConstructor;
 
-    private final Deserializers deserializers;
     private final NotNullLazyValue<Annotations> annotations;
 
     private final NullableLazyValue<ClassDescriptor> classObjectDescriptor;
@@ -72,33 +71,22 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
     private final Visibility visibility;
     private final ClassKind kind;
     private final boolean isInner;
-    private final DescriptorFinder descriptorFinder;
-    private final PackageFragmentProvider packageFragmentProvider;
+    private final DeserializationContextWithTypes context;
 
-    public DeserializedClassDescriptor(
-            @NotNull StorageManager storageManager,
-            @NotNull Deserializers deserializers,
-            @NotNull DescriptorFinder descriptorFinder,
-            @NotNull PackageFragmentProvider packageFragmentProvider,
-            @NotNull NameResolver nameResolver,
-            @NotNull ProtoBuf.Class classProto
-    ) {
-        super(storageManager, nameResolver.getClassId(classProto.getFqName()).getRelativeClassName().shortName());
+    public DeserializedClassDescriptor(@NotNull DeserializationGlobalContext globalContext, @NotNull ClassData classData) {
+        this(globalContext.withNameResolver(classData.getNameResolver()), classData.getClassProto());
+    }
+
+    public DeserializedClassDescriptor(@NotNull DeserializationContext outerContext, @NotNull ProtoBuf.Class classProto) {
+        super(outerContext.getStorageManager(),
+              outerContext.getNameResolver().getClassId(classProto.getFqName()).getRelativeClassName().shortName());
         this.classProto = classProto;
-        this.classId = nameResolver.getClassId(classProto.getFqName());
-        this.storageManager = storageManager;
-        this.packageFragmentProvider = packageFragmentProvider;
-        this.descriptorFinder = descriptorFinder;
+        this.classId = outerContext.getNameResolver().getClassId(classProto.getFqName());
 
-        TypeDeserializer notNullTypeDeserializer = new TypeDeserializer(storageManager, null, nameResolver,
-                                                                        descriptorFinder, "Deserializer for class " + getName(), NONE);
-        DescriptorDeserializer outerDeserializer = DescriptorDeserializer.create(storageManager, notNullTypeDeserializer,
-                                                                                 this, nameResolver, deserializers);
         List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>(classProto.getTypeParameterCount());
-        this.deserializer = outerDeserializer.createChildDeserializer(this, classProto.getTypeParameterList(), typeParameters);
-        this.typeDeserializer = deserializer.getTypeDeserializer();
+        this.context = outerContext.withTypes(this).childContext(this, classProto.getTypeParameterList(), typeParameters);
 
-        this.containingDeclaration = storageManager.createLazyValue(new Function0<DeclarationDescriptor>() {
+        this.containingDeclaration = outerContext.getStorageManager().createLazyValue(new Function0<DeclarationDescriptor>() {
             @Override
             public DeclarationDescriptor invoke() {
                 return computeContainingDeclaration();
@@ -106,30 +94,29 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
         });
 
         this.typeConstructor = new DeserializedClassTypeConstructor(typeParameters);
-        this.memberScope = new DeserializedClassMemberScope(storageManager, this);
+        this.memberScope = new DeserializedClassMemberScope();
 
         int flags = classProto.getFlags();
-        this.modality = DescriptorDeserializer.modality(Flags.MODALITY.get(flags));
-        this.visibility = DescriptorDeserializer.visibility(Flags.VISIBILITY.get(flags));
-        this.kind = DescriptorDeserializer.classKind(Flags.CLASS_KIND.get(flags));
+        this.modality = modality(Flags.MODALITY.get(flags));
+        this.visibility = visibility(Flags.VISIBILITY.get(flags));
+        this.kind = classKind(Flags.CLASS_KIND.get(flags));
         this.isInner = Flags.INNER.get(flags);
 
-        this.deserializers = deserializers;
-        this.annotations = storageManager.createLazyValue(new Function0<Annotations>() {
+        this.annotations = context.getStorageManager().createLazyValue(new Function0<Annotations>() {
             @Override
             public Annotations invoke() {
                 return computeAnnotations();
             }
         });
 
-        this.primaryConstructor = storageManager.createNullableLazyValue(new Function0<ConstructorDescriptor>() {
+        this.primaryConstructor = context.getStorageManager().createNullableLazyValue(new Function0<ConstructorDescriptor>() {
             @Override
             public ConstructorDescriptor invoke() {
                 return computePrimaryConstructor();
             }
         });
 
-        this.classObjectDescriptor = storageManager.createNullableLazyValue(new Function0<ClassDescriptor>() {
+        this.classObjectDescriptor = context.getStorageManager().createNullableLazyValue(new Function0<ClassDescriptor>() {
             @Override
             public ClassDescriptor invoke() {
                 return computeClassObjectDescriptor();
@@ -148,12 +135,13 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
     @NotNull
     private DeclarationDescriptor computeContainingDeclaration() {
         if (classId.isTopLevelClass()) {
-            List<PackageFragmentDescriptor> fragments = packageFragmentProvider.getPackageFragments(classId.getPackageFqName());
+            List<PackageFragmentDescriptor> fragments =
+                    context.getPackageFragmentProvider().getPackageFragments(classId.getPackageFqName());
             assert fragments.size() == 1 : "there should be exactly one package: " + fragments;
             return fragments.iterator().next();
         }
         else {
-            ClassOrPackageFragmentDescriptor result = descriptorFinder.findClass(classId.getOuterClassId());
+            ClassDescriptor result = context.getDescriptorFinder().findClass(classId.getOuterClassId());
             return result != null ? result : ErrorUtils.getErrorModule();
         }
     }
@@ -192,7 +180,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
         if (!Flags.HAS_ANNOTATIONS.get(classProto.getFlags())) {
             return Annotations.EMPTY;
         }
-        return deserializers.getAnnotationDeserializer().loadClassAnnotations(this, classProto);
+        return context.getAnnotationDeserializer().loadClassAnnotations(this, classProto);
     }
 
     @NotNull
@@ -218,7 +206,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
             return descriptor;
         }
 
-        return (ConstructorDescriptor) deserializer.loadCallable(constructorProto.getData());
+        return (ConstructorDescriptor) context.getDeserializer().loadCallable(constructorProto.getData());
     }
 
     @Nullable
@@ -254,11 +242,10 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
                 throw new IllegalStateException("Object should have a serialized class object: " + classId);
             }
 
-            return new DeserializedClassDescriptor(storageManager, deserializers, descriptorFinder, packageFragmentProvider,
-                                                   deserializer.getNameResolver(), classObjectProto.getData());
+            return new DeserializedClassDescriptor(context, classObjectProto.getData());
         }
 
-        return descriptorFinder.findClass(classId.createNestedClassId(getClassObjectName(getName())));
+        return context.getDescriptorFinder().findClass(classId.createNestedClassId(getClassObjectName(getName())));
     }
 
     @NotNull
@@ -313,7 +300,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
     private Collection<JetType> computeSuperTypes() {
         List<JetType> supertypes = new ArrayList<JetType>(classProto.getSupertypeCount());
         for (ProtoBuf.Type supertype : classProto.getSupertypeList()) {
-            supertypes.add(typeDeserializer.type(supertype));
+            supertypes.add(context.getTypeDeserializer().type(supertype));
         }
         return supertypes;
     }
@@ -384,12 +371,12 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
         }
     }
 
-    private static class DeserializedClassMemberScope extends DeserializedMemberScope {
+    private class DeserializedClassMemberScope extends DeserializedMemberScope {
         private final DeserializedClassDescriptor classDescriptor;
 
-        public DeserializedClassMemberScope(@NotNull StorageManager storageManager, @NotNull DeserializedClassDescriptor classDescriptor) {
-            super(storageManager, classDescriptor, classDescriptor.deserializer, classDescriptor.classProto.getMemberList());
-            this.classDescriptor = classDescriptor;
+        public DeserializedClassMemberScope() {
+            super(context, DeserializedClassDescriptor.this.classProto.getMemberList());
+            this.classDescriptor = DeserializedClassDescriptor.this;
         }
 
         @Override
@@ -485,6 +472,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
             this.nestedClassNames = nestedClassNames();
             this.enumEntryNames = enumEntryNames();
 
+            final StorageManager storageManager = context.getStorageManager();
             final NotNullLazyValue<Collection<Name>> enumMemberNames = storageManager.createLazyValue(new Function0<Collection<Name>>() {
                 @Override
                 public Collection<Name> invoke() {
@@ -500,7 +488,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
                                 .create(storageManager, DeserializedClassDescriptor.this, name, enumMemberNames);
                     }
                     if (nestedClassNames.contains(name)) {
-                        return descriptorFinder.findClass(classId.createNestedClassId(name));
+                        return context.getDescriptorFinder().findClass(classId.createNestedClassId(name));
                     }
                     return null;
                 }
@@ -510,7 +498,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
         @NotNull
         private Set<Name> nestedClassNames() {
             Set<Name> result = new HashSet<Name>();
-            NameResolver nameResolver = deserializer.getNameResolver();
+            NameResolver nameResolver = context.getNameResolver();
             for (Integer index : classProto.getNestedClassNameList()) {
                 result.add(nameResolver.getName(index));
             }
@@ -524,7 +512,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
             }
 
             Set<Name> result = new HashSet<Name>();
-            NameResolver nameResolver = deserializer.getNameResolver();
+            NameResolver nameResolver = context.getNameResolver();
             for (Integer index : classProto.getEnumEntryList()) {
                 result.add(nameResolver.getName(index));
             }
@@ -543,7 +531,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
                 }
             }
 
-            final NameResolver nameResolver = deserializer.getNameResolver();
+            final NameResolver nameResolver = context.getNameResolver();
             return KotlinPackage.mapTo(classProto.getMemberList(), result, new Function1<ProtoBuf.Callable, Name>() {
                 @Override
                 public Name invoke(@NotNull ProtoBuf.Callable callable) {

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

@@ -20,9 +20,9 @@ import kotlin.Function0;
 import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer;
 import org.jetbrains.jet.descriptors.serialization.Flags;
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -49,51 +49,50 @@ public abstract class DeserializedMemberScope implements JetScope {
         }
     };
 
-    private final DeclarationDescriptor containingDeclaration;
-    private final DescriptorDeserializer deserializer;
-
     // Never modified after creation
     private final Map<Name, List<ProtoBuf.Callable>> membersProtos;
 
     private final MemoizedFunctionToNotNull<Name, Collection<FunctionDescriptor>> functions;
     private final MemoizedFunctionToNotNull<Name, Collection<VariableDescriptor>> properties;
     private final NotNullLazyValue<Collection<DeclarationDescriptor>> allDescriptors;
+    private final DeserializationContextWithTypes context;
 
     protected DeserializedMemberScope(
-            @NotNull StorageManager storageManager,
-            @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull DescriptorDeserializer deserializer,
+            @NotNull DeserializationContextWithTypes context,
             @NotNull Collection<ProtoBuf.Callable> membersList
     ) {
-        this.containingDeclaration = containingDeclaration;
-        this.deserializer = deserializer;
-
+        this.context = context;
         this.membersProtos = groupByName(membersList);
+        StorageManager storageManager = context.getStorageManager();
         this.functions = storageManager.createMemoizedFunction(new Function1<Name, Collection<FunctionDescriptor>>() {
             @Override
             public Collection<FunctionDescriptor> invoke(Name name) {
                 return computeFunctions(name);
             }
         });
-        this.properties = storageManager.createMemoizedFunction(new Function1<Name, Collection<VariableDescriptor>>() {
-            @Override
-            public Collection<VariableDescriptor> invoke(Name name) {
-                return computeProperties(name);
-            }
-        });
-        this.allDescriptors = storageManager.createLazyValue(new Function0<Collection<DeclarationDescriptor>>() {
-            @Override
-            public Collection<DeclarationDescriptor> invoke() {
-                return computeAllDescriptors();
-            }
-        });
+        this.properties = storageManager.createMemoizedFunction(
+                new Function1<Name, Collection<VariableDescriptor>>() {
+                    @Override
+                    public Collection<VariableDescriptor> invoke(Name name) {
+                        return computeProperties(name);
+                    }
+                }
+        );
+        this.allDescriptors = storageManager.createLazyValue(
+                new Function0<Collection<DeclarationDescriptor>>() {
+                    @Override
+                    public Collection<DeclarationDescriptor> invoke() {
+                        return computeAllDescriptors();
+                    }
+                }
+        );
     }
 
     @NotNull
     private Map<Name, List<ProtoBuf.Callable>> groupByName(@NotNull Collection<ProtoBuf.Callable> membersList) {
         Map<Name, List<ProtoBuf.Callable>> map = new HashMap<Name, List<ProtoBuf.Callable>>();
         for (ProtoBuf.Callable memberProto : membersList) {
-            Name name = deserializer.getNameResolver().getName(memberProto.getName());
+            Name name = context.getNameResolver().getName(memberProto.getName());
             List<ProtoBuf.Callable> protos = map.get(name);
             if (protos == null) {
                 protos = new ArrayList<ProtoBuf.Callable>(1);
@@ -113,7 +112,7 @@ public abstract class DeserializedMemberScope implements JetScope {
             for (ProtoBuf.Callable memberProto : memberProtos) {
                 if (callableKind.accept(Flags.CALLABLE_KIND.get(memberProto.getFlags()))) {
                     //noinspection unchecked
-                    descriptors.add((D) deserializer.loadCallable(memberProto));
+                    descriptors.add((D) context.getDeserializer().loadCallable(memberProto));
                 }
             }
         }
@@ -179,7 +178,7 @@ public abstract class DeserializedMemberScope implements JetScope {
     @NotNull
     @Override
     public DeclarationDescriptor getContainingDeclaration() {
-        return containingDeclaration;
+        return context.getContainingDeclaration();
     }
 
     @NotNull
@@ -239,7 +238,7 @@ public abstract class DeserializedMemberScope implements JetScope {
         p.println(getClass().getSimpleName(), " {");
         p.pushIndent();
 
-        p.println("containingDeclaration = " + containingDeclaration);
+        p.println("containingDeclaration = " + getContainingDeclaration());
 
         p.popIndent();
         p.println("}");

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

@@ -18,7 +18,11 @@ package org.jetbrains.jet.descriptors.serialization.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.descriptors.serialization.*;
+import org.jetbrains.jet.descriptors.serialization.ClassId;
+import org.jetbrains.jet.descriptors.serialization.PackageData;
+import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext;
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
@@ -26,54 +30,43 @@ import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
 public class DeserializedPackageMemberScope extends DeserializedMemberScope {
-    private final DescriptorFinder descriptorFinder;
 
     private final FqName packageFqName;
+    private final DeserializationContext context;
 
     public DeserializedPackageMemberScope(
-            @NotNull StorageManager storageManager,
             @NotNull PackageFragmentDescriptor packageDescriptor,
-            @NotNull Deserializers deserializers,
-            @NotNull MemberFilter memberFilter,
-            @NotNull DescriptorFinder descriptorFinder,
             @NotNull ProtoBuf.Package proto,
-            @NotNull NameResolver nameResolver
+            @NotNull DeserializationContext context
     ) {
-        super(storageManager, packageDescriptor,
-              DescriptorDeserializer.create(storageManager, packageDescriptor, nameResolver, descriptorFinder, deserializers),
-              getFilteredMembers(packageDescriptor, proto, memberFilter, nameResolver));
-        this.descriptorFinder = descriptorFinder;
+        super(context.withTypes(packageDescriptor), getFilteredMembers(packageDescriptor, proto, context));
+        this.context = context;
         this.packageFqName = packageDescriptor.getFqName();
     }
 
     public DeserializedPackageMemberScope(
-            @NotNull StorageManager storageManager,
             @NotNull PackageFragmentDescriptor packageDescriptor,
-            @NotNull Deserializers deserializers,
-            @NotNull MemberFilter memberFilter,
-            @NotNull DescriptorFinder descriptorFinder,
-            @NotNull PackageData packageData
+            @NotNull PackageData packageData,
+            @NotNull DeserializationGlobalContext context
     ) {
-        this(storageManager, packageDescriptor, deserializers, memberFilter, descriptorFinder, packageData.getPackageProto(),
-             packageData.getNameResolver());
+        this(packageDescriptor, packageData.getPackageProto(), context.withNameResolver(packageData.getNameResolver()));
     }
 
     @Nullable
     @Override
     protected ClassDescriptor getClassDescriptor(@NotNull Name name) {
-        return descriptorFinder.findClass(new ClassId(packageFqName, FqNameUnsafe.topLevel(name)));
+        return context.getDescriptorFinder().findClass(new ClassId(packageFqName, FqNameUnsafe.topLevel(name)));
     }
 
     @Override
     protected void addAllClassDescriptors(@NotNull Collection<DeclarationDescriptor> result) {
-        for (Name className : descriptorFinder.getClassNames(packageFqName)) {
+        for (Name className : context.getDescriptorFinder().getClassNames(packageFqName)) {
             ClassDescriptor classDescriptor = getClassDescriptor(className);
 
             if (classDescriptor != null) {
@@ -97,12 +90,11 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope {
     private static Collection<ProtoBuf.Callable> getFilteredMembers(
             @NotNull PackageFragmentDescriptor packageDescriptor,
             @NotNull ProtoBuf.Package packageProto,
-            @NotNull MemberFilter memberFilter,
-            @NotNull NameResolver nameResolver
+            @NotNull DeserializationContext context
     ) {
         List<ProtoBuf.Callable> result = new ArrayList<ProtoBuf.Callable>();
         for (ProtoBuf.Callable member : packageProto.getMemberList()) {
-            if (memberFilter.acceptPackagePartClass(packageDescriptor, member, nameResolver)) {
+            if (context.getMemberFilter().acceptPackagePartClass(packageDescriptor, member, context.getNameResolver())) {
                 result.add(member);
             }
         }

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

@@ -18,10 +18,7 @@ package org.jetbrains.jet.descriptors.serialization.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer;
-import org.jetbrains.jet.descriptors.serialization.Flags;
-import org.jetbrains.jet.descriptors.serialization.NameResolver;
-import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
+import org.jetbrains.jet.descriptors.serialization.*;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
@@ -87,19 +84,19 @@ public class DeserializedSimpleFunctionDescriptor extends SimpleFunctionDescript
     public static DeserializedSimpleFunctionDescriptor create(
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull ProtoBuf.Callable proto,
-            @NotNull Deserializers deserializers,
+            @NotNull AnnotationDeserializer annotationDeserializer,
             @NotNull NameResolver nameResolver
     ) {
         Annotations annotations = DescriptorDeserializer.getAnnotations(containingDeclaration, proto, proto.getFlags(),
-                                                                        Deserializers.AnnotatedCallableKind.FUNCTION,
-                                                                        deserializers.getAnnotationDeserializer(),
+                                                                        AnnotatedCallableKind.FUNCTION,
+                                                                        annotationDeserializer,
                                                                         nameResolver);
         return new DeserializedSimpleFunctionDescriptor(
                 containingDeclaration,
                 null,
                 annotations,
                 nameResolver.getName(proto.getName()),
-                DescriptorDeserializer.memberKind(Flags.MEMBER_KIND.get(proto.getFlags())),
+                SerializationPackage.memberKind(Flags.MEMBER_KIND.get(proto.getFlags())),
                 proto,
                 nameResolver);
     }

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

@@ -1,48 +0,0 @@
-/*
- * Copyright 2010-2014 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.jet.descriptors.serialization.descriptors;
-
-import org.jetbrains.annotations.NotNull;
-
-public interface Deserializers {
-    Deserializers UNSUPPORTED = new Deserializers() {
-        @NotNull
-        @Override
-        public AnnotationDeserializer getAnnotationDeserializer() {
-            return AnnotationDeserializer.UNSUPPORTED;
-        }
-
-        @NotNull
-        @Override
-        public ConstantDeserializer getConstantDeserializer() {
-            return ConstantDeserializer.UNSUPPORTED;
-        }
-    };
-
-    @NotNull
-    AnnotationDeserializer getAnnotationDeserializer();
-
-    @NotNull
-    ConstantDeserializer getConstantDeserializer();
-
-    enum AnnotatedCallableKind {
-        FUNCTION,
-        PROPERTY,
-        PROPERTY_GETTER,
-        PROPERTY_SETTER
-    }
-}

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

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2010-2014 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.jet.descriptors.serialization
+
+import org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor
+import org.jetbrains.jet.lang.descriptors.Modality
+import org.jetbrains.jet.lang.descriptors.Visibilities
+import org.jetbrains.jet.lang.descriptors.ClassKind
+import org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter
+import org.jetbrains.jet.lang.types.Variance
+
+fun memberKind(memberKind: Callable.MemberKind) = when (memberKind) {
+    ProtoBuf.Callable.MemberKind.DECLARATION -> CallableMemberDescriptor.Kind.DECLARATION
+    ProtoBuf.Callable.MemberKind.FAKE_OVERRIDE -> CallableMemberDescriptor.Kind.FAKE_OVERRIDE
+    ProtoBuf.Callable.MemberKind.DELEGATION -> CallableMemberDescriptor.Kind.DELEGATION
+    ProtoBuf.Callable.MemberKind.SYNTHESIZED -> CallableMemberDescriptor.Kind.SYNTHESIZED
+}
+
+fun modality(modality: ProtoBuf.Modality) = when (modality) {
+    ProtoBuf.Modality.FINAL -> Modality.FINAL
+    ProtoBuf.Modality.OPEN -> Modality.OPEN
+    ProtoBuf.Modality.ABSTRACT -> Modality.ABSTRACT
+}
+
+fun visibility(visibility: ProtoBuf.Visibility) = when (visibility) {
+    ProtoBuf.Visibility.INTERNAL -> Visibilities.INTERNAL
+    ProtoBuf.Visibility.PRIVATE -> Visibilities.PRIVATE
+    ProtoBuf.Visibility.PROTECTED -> Visibilities.PROTECTED
+    ProtoBuf.Visibility.PUBLIC -> Visibilities.PUBLIC
+    ProtoBuf.Visibility.EXTRA -> throw UnsupportedOperationException("Extra visibilities are not supported yet")
+}
+
+public fun classKind(kind: ProtoBuf.Class.Kind): ClassKind = when (kind) {
+    ProtoBuf.Class.Kind.CLASS -> ClassKind.CLASS
+    ProtoBuf.Class.Kind.TRAIT -> ClassKind.TRAIT
+    ProtoBuf.Class.Kind.ENUM_CLASS -> ClassKind.ENUM_CLASS
+    ProtoBuf.Class.Kind.ENUM_ENTRY -> ClassKind.ENUM_ENTRY
+    ProtoBuf.Class.Kind.ANNOTATION_CLASS -> ClassKind.ANNOTATION_CLASS
+    ProtoBuf.Class.Kind.OBJECT -> ClassKind.OBJECT
+    ProtoBuf.Class.Kind.CLASS_OBJECT -> ClassKind.CLASS_OBJECT
+}
+
+fun variance(variance: TypeParameter.Variance) = when (variance) {
+    ProtoBuf.TypeParameter.Variance.IN -> Variance.IN_VARIANCE
+    ProtoBuf.TypeParameter.Variance.OUT -> Variance.OUT_VARIANCE
+    ProtoBuf.TypeParameter.Variance.INV -> Variance.INVARIANT
+}
+
+fun variance(variance: ProtoBuf.Type.Argument.Projection) = when (variance) {
+    ProtoBuf.Type.Argument.Projection.IN -> Variance.IN_VARIANCE
+    ProtoBuf.Type.Argument.Projection.OUT -> Variance.OUT_VARIANCE
+    ProtoBuf.Type.Argument.Projection.INV -> Variance.INVARIANT
+}

idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java

@@ -90,7 +90,7 @@ public class JetFromJavaDescriptorHelper {
     public static ClassKind getCompiledClassKind(@NotNull PsiClass psiClass) {
         ClassData classData = getClassData(psiClass);
         if (classData == null) return null;
-        return DescriptorDeserializer.classKind(Flags.CLASS_KIND.get(classData.getClassProto().getFlags()));
+        return SerializationPackage.classKind(Flags.CLASS_KIND.get(classData.getClassProto().getFlags()));
     }
 
 

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

@@ -40,11 +40,11 @@ import org.jetbrains.jet.lang.resolve.java.PackageClassUtils
 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.DescriptorDeserializers
 import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage
 import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer
 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
 
 public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDecompiler {
     val kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(classFile)
@@ -68,12 +68,9 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
             return Collections.emptyList()
         }
         val membersScope = DeserializedPackageMemberScope(
-                storageManager,
                 createDummyPackageFragment(packageFqName),
-                deserializers,
-                MemberFilter.ALWAYS_TRUE,
-                descriptorFinder,
-                JavaProtoBufUtil.readPackageDataFrom(annotationData)
+                JavaProtoBufUtil.readPackageDataFrom(annotationData),
+                deserializationContext
         )
         return membersScope.getAllDescriptors()
     }
@@ -132,12 +129,6 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
         constantDeserializer.setStorage(deserializerStorage)
     }
 
-    private val deserializers = DescriptorDeserializers();
-    {
-        deserializers.setAnnotationDescriptorDeserializer(annotationDeserializer)
-        deserializers.setConstantDescriptorDeserializer(constantDeserializer)
-    }
-
     private val descriptorFinder = object : DescriptorFinder {
         override fun findClass(classId: ClassId): ClassDescriptor? {
             return classes(classId)
@@ -158,6 +149,9 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
         }
     }
 
+    val deserializationContext = DeserializationGlobalContext(storageManager, descriptorFinder, annotationDeserializer,
+                                                              constantDeserializer, packageFragmentProvider, MemberFilter.ALWAYS_TRUE)
+
     private fun createDummyPackageFragment(fqName: FqName): MutablePackageFragmentDescriptor {
         return MutablePackageFragmentDescriptor(ErrorUtils.getErrorModule(), fqName)
     }
@@ -184,8 +178,7 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
             LOG.error("Annotation data missing for ${kotlinClass.getClassName()}")
         }
         val classData = JavaProtoBufUtil.readClassDataFrom(data!!)
-        return DeserializedClassDescriptor(storageManager, deserializers, descriptorFinder, packageFragmentProvider,
-                                           classData.getNameResolver(), classData.getClassProto())
+        return DeserializedClassDescriptor(deserializationContext, classData)
     }
 
     // we need a "magic" way to obtain ClassId from FqName