diff --git a/compiler/frontend.java/frontend.java.iml b/compiler/frontend.java/frontend.java.iml
index 689b119f411..b979014c075 100644
--- a/compiler/frontend.java/frontend.java.iml
+++ b/compiler/frontend.java/frontend.java.iml
@@ -12,6 +12,7 @@
     <orderEntry type="module" module-name="util" exported="" />
     <orderEntry type="module" module-name="runtime" />
     <orderEntry type="library" name="javax.inject" level="project" />
+    <orderEntry type="module" module-name="serialization" />
   </component>
 </module>
 
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java
index f0a15388e43..ef2bf2ad065 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java
@@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
@@ -60,6 +61,7 @@ public class InjectorForJavaDescriptorResolver {
     private final JavaFunctionResolver javaFunctionResolver;
     private final JavaValueParameterResolver javaValueParameterResolver;
     private final JavaSignatureResolver javaSignatureResolver;
+    private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final JavaNamespaceResolver javaNamespaceResolver;
     private final JavaConstructorResolver javaConstructorResolver;
     private final JavaInnerClassResolver javaInnerClassResolver;
@@ -87,6 +89,7 @@ public class InjectorForJavaDescriptorResolver {
         this.javaFunctionResolver = new JavaFunctionResolver();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
         this.javaSignatureResolver = new JavaSignatureResolver();
+        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
         this.javaInnerClassResolver = new JavaInnerClassResolver();
@@ -115,6 +118,7 @@ public class InjectorForJavaDescriptorResolver {
         javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
         javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
         javaClassResolver.setFunctionResolver(javaFunctionResolver);
+        javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
         javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
         javaClassResolver.setPsiClassFinder(psiClassFinder);
         javaClassResolver.setSemanticServices(javaSemanticServices);
@@ -147,6 +151,9 @@ public class InjectorForJavaDescriptorResolver {
 
         javaSignatureResolver.setJavaSemanticServices(javaSemanticServices);
 
+        deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver);
+        deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver);
+
         javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
         javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
         javaNamespaceResolver.setTrace(bindingTrace);
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java
index 1d045b66f02..afabcf0b8ab 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java
@@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
@@ -60,6 +61,7 @@ public class InjectorForJavaSemanticServices {
     private final JavaFunctionResolver javaFunctionResolver;
     private final JavaValueParameterResolver javaValueParameterResolver;
     private final JavaSignatureResolver javaSignatureResolver;
+    private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final JavaNamespaceResolver javaNamespaceResolver;
     private final JavaConstructorResolver javaConstructorResolver;
     private final JavaInnerClassResolver javaInnerClassResolver;
@@ -85,6 +87,7 @@ public class InjectorForJavaSemanticServices {
         this.javaFunctionResolver = new JavaFunctionResolver();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
         this.javaSignatureResolver = new JavaSignatureResolver();
+        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
         this.javaInnerClassResolver = new JavaInnerClassResolver();
@@ -115,6 +118,7 @@ public class InjectorForJavaSemanticServices {
         javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
         javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
         javaClassResolver.setFunctionResolver(javaFunctionResolver);
+        javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
         javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
         javaClassResolver.setPsiClassFinder(psiClassFinder);
         javaClassResolver.setSemanticServices(javaSemanticServices);
@@ -147,6 +151,9 @@ public class InjectorForJavaSemanticServices {
 
         javaSignatureResolver.setJavaSemanticServices(javaSemanticServices);
 
+        deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver);
+        deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver);
+
         javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
         javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
         javaNamespaceResolver.setTrace(bindingTrace);
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java
index 63b92638dfc..976d741e2ce 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java
@@ -58,6 +58,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
@@ -110,6 +111,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final JavaFunctionResolver javaFunctionResolver;
     private final JavaValueParameterResolver javaValueParameterResolver;
     private final JavaSignatureResolver javaSignatureResolver;
+    private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final JavaNamespaceResolver javaNamespaceResolver;
     private final JavaConstructorResolver javaConstructorResolver;
     private final JavaInnerClassResolver javaInnerClassResolver;
@@ -163,6 +165,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.javaFunctionResolver = new JavaFunctionResolver();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
         this.javaSignatureResolver = new JavaSignatureResolver();
+        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
         this.javaConstructorResolver = new JavaConstructorResolver();
         this.javaInnerClassResolver = new JavaInnerClassResolver();
@@ -293,6 +296,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
         javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
         javaClassResolver.setFunctionResolver(javaFunctionResolver);
+        javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
         javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
         javaClassResolver.setPsiClassFinder(psiClassFinder);
         javaClassResolver.setSemanticServices(javaSemanticServices);
@@ -325,6 +329,9 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         javaSignatureResolver.setJavaSemanticServices(javaSemanticServices);
 
+        deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver);
+        deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver);
+
         javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
         javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
         javaNamespaceResolver.setTrace(bindingTrace);
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java
new file mode 100644
index 00000000000..54e60b7e813
--- /dev/null
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java
@@ -0,0 +1,291 @@
+/*
+ * Copyright 2010-2013 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.java.resolver;
+
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiClass;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.asm4.AnnotationVisitor;
+import org.jetbrains.asm4.ClassReader;
+import org.jetbrains.asm4.ClassVisitor;
+import org.jetbrains.asm4.Opcodes;
+import org.jetbrains.jet.descriptors.serialization.*;
+import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
+import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager;
+import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
+
+import javax.inject.Inject;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.jetbrains.asm4.ClassReader.*;
+import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN;
+
+public final class DeserializedDescriptorResolver {
+
+    private static final Logger LOG = Logger.getInstance(DeserializedDescriptorResolver.class);
+    private static final String KOTLIN_INFO_TYPE = JvmStdlibNames.KOTLIN_INFO_CLASS.getAsmType().toString();
+
+    public static final AnnotationDeserializer DUMMY_ANNOTATION_DESERIALIZER = new AnnotationDeserializer() {
+        @NotNull
+        @Override
+        public List<AnnotationDescriptor> loadClassAnnotations(@NotNull ProtoBuf.Class classProto) {
+            // This is a hack for tests: only data annotations are present in test data so far
+            AnnotationDescriptor annotationDescriptor = new AnnotationDescriptor();
+            annotationDescriptor.setAnnotationType(KotlinBuiltIns.getInstance().getDataClassAnnotation().getDefaultType());
+            return Collections.singletonList(annotationDescriptor);
+        }
+
+        @NotNull
+        @Override
+        public List<AnnotationDescriptor> loadCallableAnnotations(@NotNull ProtoBuf.Callable callableProto) {
+            throw new UnsupportedOperationException(); // TODO
+        }
+
+        @NotNull
+        @Override
+        public List<AnnotationDescriptor> loadSetterAnnotations(@NotNull ProtoBuf.Callable callableProto) {
+            throw new UnsupportedOperationException(); // TODO
+        }
+
+        @NotNull
+        @Override
+        public List<AnnotationDescriptor> loadValueParameterAnnotations(@NotNull ProtoBuf.Callable.ValueParameter parameterProto) {
+            throw new UnsupportedOperationException(); // TODO
+        }
+    };
+
+    @NotNull
+    private final LockBasedStorageManager storageManager = new LockBasedStorageManager();
+
+    private JavaNamespaceResolver javaNamespaceResolver;
+
+    private JavaClassResolver javaClassResolver;
+
+    @Inject
+    public void setJavaNamespaceResolver(JavaNamespaceResolver javaNamespaceResolver) {
+        this.javaNamespaceResolver = javaNamespaceResolver;
+    }
+
+    @Inject
+    public void setJavaClassResolver(JavaClassResolver javaClassResolver) {
+        this.javaClassResolver = javaClassResolver;
+    }
+
+    @Nullable
+    public ClassDescriptor resolveClass(
+            @NotNull FqName fqName,
+            @NotNull PsiClass psiClass,
+            @NotNull ClassOrNamespaceDescriptor containingDeclaration
+    ) {
+        VirtualFile virtualFile = getVirtualFile(psiClass, fqName, containingDeclaration);
+        if (virtualFile == null) {
+            return null;
+        }
+        ClassData classData = readClassDataFromClassFile(virtualFile);
+        if (classData == null) {
+            return null;
+        }
+        return deserializeClass(classData, fqName, containingDeclaration);
+    }
+
+    @Nullable
+    private static VirtualFile getVirtualFile(
+            @NotNull PsiClass psiClass,
+            @NotNull FqName classFqName,
+            @NotNull ClassOrNamespaceDescriptor containingDeclaration
+    ) {
+        VirtualFile mostOuterClassVirtualFile = psiClass.getContainingFile().getVirtualFile();
+        if (mostOuterClassVirtualFile == null) {
+            LOG.error("No virtual file for " + psiClass.getQualifiedName());
+            return null;
+        }
+        String fileExtension = mostOuterClassVirtualFile.getExtension();
+        if (fileExtension == null || !fileExtension.equals("class")) {
+            return null;
+        }
+        ClassId id = ClassId.fromFqNameAndContainingDeclaration(classFqName, containingDeclaration);
+        FqNameUnsafe relativeClassName = id.getRelativeClassName();
+        assert relativeClassName.isSafe() : "Relative class name " + relativeClassName.asString() + " should be safe at this point";
+        String classNameWithBucks = relativeClassName.asString().replace(".", "$") + ".class";
+        VirtualFile virtualFile = mostOuterClassVirtualFile.getParent().findChild(classNameWithBucks);
+        if (virtualFile == null) {
+            LOG.error("No virtual file for " + psiClass.getQualifiedName());
+            return null;
+        }
+        return virtualFile;
+    }
+
+    @Nullable
+    private ClassDescriptor deserializeClass(
+            @NotNull ClassData classData,
+            @NotNull FqName fqName,
+            @NotNull ClassOrNamespaceDescriptor containingDeclaration
+    ) {
+        ClassId classId = ClassId.fromFqNameAndContainingDeclaration(fqName, containingDeclaration);
+        AbstractClassResolver classResolver =
+                new DeserializedClassResolver(storageManager, DUMMY_ANNOTATION_DESERIALIZER, classId, classData);
+        ClassDescriptor classDescriptor = classResolver.findClassInternally(classId);
+        assert classDescriptor != null : "Could not correctly deserialize class " + fqName.asString();
+        return classDescriptor;
+    }
+
+    @Nullable
+    private static ClassData readClassDataFromClassFile(@NotNull VirtualFile virtualFile) {
+        try {
+            InputStream inputStream = virtualFile.getInputStream();
+            try {
+                ClassReader reader = new ClassReader(inputStream);
+                GetKotlinInfoDataVisitor visitor = new GetKotlinInfoDataVisitor();
+                reader.accept(visitor, SKIP_CODE | SKIP_FRAMES | SKIP_DEBUG);
+                return visitor.getClassData();
+            }
+            finally {
+                inputStream.close();
+            }
+        }
+        catch (IOException e) {
+            LOG.error(e);
+        }
+        return null;
+    }
+
+    private static class GetKotlinInfoDataVisitor extends ClassVisitor {
+        public GetKotlinInfoDataVisitor() {
+            super(Opcodes.ASM4);
+        }
+
+        @Nullable
+        private byte[] data = null;
+
+        @Override
+        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+            if (!desc.equals(KOTLIN_INFO_TYPE)) {
+                return null;
+            }
+            return new AnnotationVisitor(Opcodes.ASM4) {
+                @Override
+                public void visit(String name, Object value) {
+                    if (name.equals("data")) {
+                        data = (byte[]) value;
+                    }
+                    else {
+                        LOG.error("Unexpected property " + name + " for annotation " + KOTLIN_INFO_TYPE);
+                    }
+                }
+            };
+        }
+
+        @Nullable
+        private ClassData getClassData() {
+            if (data == null) {
+                return null;
+            }
+            return ClassSerializationUtil.readClassDataFrom(data);
+        }
+    }
+
+    @NotNull
+    private static FqName kotlinFqNameToJavaFqName(@NotNull FqNameUnsafe kotlinFqName) {
+        List<String> correctedSegments = new ArrayList<String>();
+        for (Name segment : kotlinFqName.pathSegments()) {
+            if (segment.asString().startsWith("<class-object-for")) {
+                correctedSegments.add(JvmAbi.CLASS_OBJECT_CLASS_NAME);
+            }
+            else {
+                assert !segment.isSpecial();
+                correctedSegments.add(segment.asString());
+            }
+        }
+        return FqName.fromSegments(correctedSegments);
+    }
+
+    public class DeserializedClassResolver extends AbstractClassResolver {
+        @NotNull
+        private final ClassId classID;
+        @NotNull
+        private final ClassData classData;
+
+        public DeserializedClassResolver(
+                @NotNull StorageManager storageManager,
+                @NotNull AnnotationDeserializer annotationDeserializer,
+                @NotNull ClassId id,
+                @NotNull ClassData data
+        ) {
+            super(storageManager, annotationDeserializer);
+            this.classID = id;
+            this.classData = data;
+        }
+
+        @Nullable
+        @Override
+        protected ClassData getClassData(@NotNull ClassId classId) {
+            if (!classId.equals(classID)) {
+                return null;
+            }
+            return classData;
+        }
+
+        @NotNull
+        @Override
+        protected DeclarationDescriptor getPackage(@NotNull FqName fqName) {
+            NamespaceDescriptor namespaceDescriptor = javaNamespaceResolver.resolveNamespace(fqName, INCLUDE_KOTLIN);
+            assert namespaceDescriptor != null;
+            return namespaceDescriptor;
+        }
+
+        @NotNull
+        @Override
+        protected ClassId getClassId(@NotNull ClassDescriptor classDescriptor) {
+            return ClassSerializationUtil.getClassId(classDescriptor, DescriptorNamer.DEFAULT);
+        }
+
+        @Nullable
+        @Override
+        protected ClassDescriptor resolveClassExternally(@NotNull ClassId classId) {
+            return javaClassResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName()));
+        }
+
+        @NotNull
+        @Override
+        protected Name getClassObjectName(@NotNull ClassDescriptor outerClass) {
+            return DescriptorUtils.getClassObjectName(outerClass.getName());
+        }
+
+        @Override
+        protected void classDescriptorCreated(@NotNull ClassDescriptor classDescriptor) {
+            //nothing to do here
+        }
+    }
+}
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java
index eeeab66ec1c..2fe9b7f2e0e 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java
@@ -86,6 +86,7 @@ public final class JavaClassResolver {
     private JavaClassObjectResolver classObjectResolver;
     private JavaSupertypeResolver supertypesResolver;
     private JavaFunctionResolver functionResolver;
+    private DeserializedDescriptorResolver kotlinDescriptorResolver;
 
     public JavaClassResolver() {
     }
@@ -95,6 +96,11 @@ public final class JavaClassResolver {
         this.trace = trace;
     }
 
+    @Inject
+    public void setKotlinDescriptorResolver(DeserializedDescriptorResolver kotlinDescriptorResolver) {
+        this.kotlinDescriptorResolver = kotlinDescriptorResolver;
+    }
+
     @Inject
     public void setSignatureResolver(JavaSignatureResolver signatureResolver) {
         this.signatureResolver = signatureResolver;
@@ -224,9 +230,15 @@ public final class JavaClassResolver {
 
         assert (!unresolvedCache.contains(fqName)) : "We can resolve the class, so it can't be 'unresolved' during parent resolution";
 
+        ClassDescriptor deserializedDescriptor = kotlinDescriptorResolver.resolveClass(fqName, psiClass, containingDeclaration);
+        if (deserializedDescriptor != null) {
+            //TODO: class object and psi class
+            cache(javaClassToKotlinFqName(fqName), deserializedDescriptor);
+            return deserializedDescriptor;
+        }
+
         return doCreateClassDescriptor(fqName, psiClass, taskList, containingDeclaration);
     }
-
     @NotNull
     private ClassDescriptorFromJvmBytecode doCreateClassDescriptor(
             @NotNull FqName fqName,
@@ -451,4 +463,4 @@ public final class JavaClassResolver {
     public ClassDescriptor resolveClass(FqName name) {
         return resolveClass(name, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractClassResolver.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractClassResolver.java
index b9bfe56d753..4fc4e235f3f 100644
--- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractClassResolver.java
+++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractClassResolver.java
@@ -69,7 +69,7 @@ public abstract class AbstractClassResolver implements ClassResolver {
 
                 AbstractClassResolver _this = AbstractClassResolver.this;
                 ClassDescriptor classDescriptor = new DeserializedClassDescriptor(
-                        storageManager,  owner, classData.getNameResolver(), _this.annotationDeserializer,
+                        storageManager, owner, classData.getNameResolver(), _this.annotationDeserializer,
                         _this, nestedClassResolver, classProto, null
                 );
                 classDescriptorCreated(classDescriptor);
@@ -81,6 +81,16 @@ public abstract class AbstractClassResolver implements ClassResolver {
     @Nullable
     @Override
     public ClassDescriptor findClass(@NotNull ClassId classId) {
+        ClassDescriptor externalClassDescriptor = resolveClassExternally(classId);
+        if (externalClassDescriptor != null) {
+            return externalClassDescriptor;
+        }
+        return findClassInternally(classId);
+    }
+
+    //do not call resolveClassExternally
+    @Nullable
+    public ClassDescriptor findClassInternally(@NotNull ClassId classId) {
         return findClass.fun(classId);
     }
 
@@ -93,6 +103,12 @@ public abstract class AbstractClassResolver implements ClassResolver {
     @NotNull
     protected abstract ClassId getClassId(@NotNull ClassDescriptor classDescriptor);
 
+    @Nullable
+    protected ClassDescriptor resolveClassExternally(@NotNull ClassId classId) {
+        //TODO: decide whether it is ok to provide default implementation
+        return null;
+    }
+
     @NotNull
     protected abstract Name getClassObjectName(@NotNull ClassDescriptor outerClass);
 
diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassId.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassId.java
index 031b6525e29..45c5adc8c59 100644
--- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassId.java
+++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassId.java
@@ -1,14 +1,44 @@
 package org.jetbrains.jet.descriptors.serialization;
 
+import com.intellij.util.Function;
+import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 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 java.util.List;
+
 public final class ClassId {
     private final FqName packageFqName;
     private final FqNameUnsafe relativeClassName;
 
+    @NotNull
+    public static ClassId fromFqNameAndContainingDeclaration(
+            @NotNull FqName fqName,
+            @NotNull ClassOrNamespaceDescriptor containingDeclaration
+    ) {
+        NamespaceDescriptor containingNamespace = DescriptorUtils.getParentOfType(containingDeclaration, NamespaceDescriptor.class, false);
+        assert containingNamespace != null;
+        List<Name> fullNameSegments = fqName.pathSegments();
+        FqName namespaceFqName = DescriptorUtils.getFQName(containingNamespace).toSafe();
+        List<Name> namespaceNameSegments = namespaceFqName.pathSegments();
+        for (int i = 0; i < namespaceNameSegments.size(); ++i) {
+            assert fullNameSegments.get(i).equals(namespaceNameSegments.get(i));
+        }
+        List<Name> relativeNameSegments = fullNameSegments.subList(namespaceNameSegments.size(), fullNameSegments.size());
+        FqName relativeFqName = FqName.fromSegments(ContainerUtil.map2List(relativeNameSegments, new Function<Name, String>() {
+            @Override
+            public String fun(Name name) {
+                return name.asString();
+            }
+        }));
+        return new ClassId(namespaceFqName, relativeFqName.toUnsafe());
+    }
+
     public ClassId(@NotNull FqName packageFqName, @NotNull FqNameUnsafe relativeClassName) {
         this.packageFqName = packageFqName;
         assert !relativeClassName.isRoot() : "Class name must not be root. " + packageFqName;
diff --git a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java
index d51ae06d7eb..640bb4de098 100644
--- a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java
+++ b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java
@@ -26,7 +26,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
-import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -39,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment;
 import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager;
@@ -51,7 +51,6 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.test.util.NamespaceComparator;
 
 import java.io.*;
@@ -79,41 +78,6 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
         }
     };
 
-    public static final AnnotationDeserializer DUMMY_ANNOTATION_DESERIALIZER = new AnnotationDeserializer() {
-        @NotNull
-        @Override
-        public List<AnnotationDescriptor> loadClassAnnotations(
-                @NotNull ProtoBuf.Class classProto
-        ) {
-            // This is a hack for tests: only data annotations are present in test data so far
-            AnnotationDescriptor annotationDescriptor = new AnnotationDescriptor();
-            annotationDescriptor.setAnnotationType(KotlinBuiltIns.getInstance().getDataClassAnnotation().getDefaultType());
-            return Collections.singletonList(annotationDescriptor);
-        }
-
-        @NotNull
-        @Override
-        public List<AnnotationDescriptor> loadCallableAnnotations(
-                @NotNull ProtoBuf.Callable callableProto
-        ) {
-            throw new UnsupportedOperationException(); // TODO
-        }
-
-        @NotNull
-        @Override
-        public List<AnnotationDescriptor> loadSetterAnnotations(@NotNull ProtoBuf.Callable callableProto) {
-            throw new UnsupportedOperationException(); // TODO
-        }
-
-        @NotNull
-        @Override
-        public List<AnnotationDescriptor> loadValueParameterAnnotations(
-                @NotNull ProtoBuf.Callable.ValueParameter parameterProto
-        ) {
-            throw new UnsupportedOperationException(); // TODO
-        }
-    };
-
     @Override
     protected JetCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY);
@@ -400,8 +364,8 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
             };
 
             NameResolver nameResolver = new NameResolver(classMetadata.simpleNames, classMetadata.qualifiedNames);
-            return new DeserializedClassDescriptor(new LockBasedStorageManager(), containingDeclaration, nameResolver, DUMMY_ANNOTATION_DESERIALIZER,
-                                                   this, nestedClassResolver, classMetadata.classProto, null);
+            return new DeserializedClassDescriptor(new LockBasedStorageManager(), containingDeclaration, nameResolver,
+                    DeserializedDescriptorResolver.DUMMY_ANNOTATION_DESERIALIZER, this, nestedClassResolver, classMetadata.classProto, null);
         }
 
         @Nullable