Using ClassId instead of FqName

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassId.java

@@ -0,0 +1,62 @@
+package org.jetbrains.jet.descriptors.serialization;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+
+public final class ClassId {
+    private final FqName packageFqName;
+    private final FqName relativeClassName;
+
+    public ClassId(@NotNull FqName packageFqName, @NotNull FqName relativeClassName) {
+        this.packageFqName = packageFqName;
+        assert !relativeClassName.isRoot() : "Class name must not be root. " + packageFqName;
+        this.relativeClassName = relativeClassName;
+    }
+
+    @NotNull
+    public FqName getPackageFqName() {
+        return packageFqName;
+    }
+
+    @NotNull
+    public FqName getRelativeClassName() {
+        return relativeClassName;
+    }
+
+    @NotNull
+    public ClassId createNestedClassId(@NotNull Name name) {
+        return new ClassId(getPackageFqName(), relativeClassName.child(name));
+    }
+
+    public FqName asSingleFqName() {
+        if (packageFqName.isRoot()) return relativeClassName;
+        return new FqName(packageFqName.getFqName() + "." + relativeClassName.getFqName());
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        ClassId id = (ClassId) o;
+
+        if (!packageFqName.equals(id.packageFqName)) return false;
+        if (!relativeClassName.equals(id.relativeClassName)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = packageFqName.hashCode();
+        result = 31 * result + relativeClassName.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        if (packageFqName.isRoot()) return "/" + relativeClassName;
+        return packageFqName.toString().replace('.', '/') + "/" + relativeClassName;
+    }
+}

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassResolver.java

@@ -19,18 +19,17 @@ package org.jetbrains.jet.descriptors.serialization;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.resolve.name.FqName;
 
 public interface ClassResolver {
 
     ClassResolver EMPTY = new ClassResolver() {
         @Nullable
         @Override
-        public ClassDescriptor findClass(@NotNull FqName fqName) {
+        public ClassDescriptor findClass(@NotNull ClassId classId) {
             return null;
         }
     };
 
     @Nullable
-    ClassDescriptor findClass(@NotNull FqName fqName);
+    ClassDescriptor findClass(@NotNull ClassId classId);
 }

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java

@@ -23,6 +23,8 @@ import org.jetbrains.jet.lang.types.TypeConstructor;
 import org.jetbrains.jet.lang.types.TypeProjection;
 import org.jetbrains.jet.lang.types.Variance;
 
+import java.util.Collection;
+
 public class DescriptorSerializer {
 
     // TODO: flags
@@ -72,18 +74,13 @@ public class DescriptorSerializer {
             builder.addSupertypes(local.type(supertype));
         }
 
-        // TODO: nested classes
-
         ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
         if (primaryConstructor != null) {
             builder.setPrimaryConstructor(local.callableProto(primaryConstructor));
         }
         // TODO: other constructors
 
-        // TODO: class object
-
         for (DeclarationDescriptor descriptor : classDescriptor.getDefaultType().getMemberScope().getAllDescriptors()) {
-            // TODO: other than functions
             if (descriptor instanceof CallableMemberDescriptor) {
                 CallableMemberDescriptor member = (CallableMemberDescriptor) descriptor;
                 if (member.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) continue;
@@ -91,6 +88,23 @@ public class DescriptorSerializer {
             }
         }
 
+        Collection<DeclarationDescriptor> nestedClasses = classDescriptor.getUnsubstitutedInnerClassesScope().getAllDescriptors();
+        for (DeclarationDescriptor descriptor : nestedClasses) {
+            ClassDescriptor nestedClass = (ClassDescriptor) descriptor;
+            int nameIndex = nameTable.getSimpleNameIndex(nestedClass.getName());
+            if (nestedClass.getKind().isObject()) {
+                builder.addNestedObjectNames(nameIndex);
+            }
+            else {
+                builder.addNestedClassNames(nameIndex);
+            }
+        }
+
+        if (classDescriptor.getClassObjectDescriptor() != null) {
+            // false is default
+            builder.setClassObjectPresent(true);
+        }
+
         return builder;
     }
 

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameResolver.java

@@ -22,6 +22,8 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
+import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.QualifiedNameTable.*;
+
 public class NameResolver {
     private final ProtoBuf.SimpleNameTable simpleNames;
     private final ProtoBuf.QualifiedNameTable qualifiedNames;
@@ -51,26 +53,54 @@ public class NameResolver {
             return classDescriptors[fqNameIndex];
         }
 
-        ProtoBuf.QualifiedNameTable.QualifiedName fqNameProto = qualifiedNames.getQualifiedNames(fqNameIndex);
+        QualifiedName fqNameProto = qualifiedNames.getQualifiedNames(fqNameIndex);
-        assert fqNameProto.getKind() == ProtoBuf.QualifiedNameTable.QualifiedName.Kind.CLASS : "Not a class fqName: " + getFqName(fqNameIndex);
+        assert fqNameProto.getKind() == QualifiedName.Kind.CLASS : "Not a class fqName: " + getClassId(fqNameIndex);
 
-        return classResolver.findClass(getFqName(fqNameIndex));
+
+        ClassId classId = getClassId(fqNameIndex);
+        return classResolver.findClass(classId);
     }
 
     @NotNull
-    public FqName getFqName(int index) {
+    public ClassId getClassId(int index) {
-        ProtoBuf.QualifiedNameTable.QualifiedName fqNameProto = qualifiedNames.getQualifiedNames(index);
+        QualifiedName fqNameProto = qualifiedNames.getQualifiedNames(index);
-        StringBuilder sb = renderFqName(new StringBuilder(), fqNameProto);
+
-        return new FqName(sb.toString());
+        StringBuilder relativeClassName = new StringBuilder();
+        QualifiedName packageFqNameProto = renderFqName(relativeClassName, fqNameProto, QualifiedName.Kind.CLASS);
+
+        FqName packageFqName;
+        if (packageFqNameProto != null) {
+            StringBuilder sb = new StringBuilder();
+            QualifiedName mustBeNull = renderFqName(sb, packageFqNameProto, QualifiedName.Kind.PACKAGE);
+            assert mustBeNull == null : "Prefix of an fqName must be all of kind PACKAGE";
+
+            packageFqName = new FqName(sb.toString());
+        }
+        else {
+            packageFqName = FqName.ROOT;
+        }
+
+        return new ClassId(packageFqName, new FqName(relativeClassName.toString()));
     }
 
-    private StringBuilder renderFqName(StringBuilder sb, ProtoBuf.QualifiedNameTable.QualifiedName fqNameProto) {
+    @Nullable
+    private QualifiedName renderFqName(
+            StringBuilder sb,
+            QualifiedName fqNameProto,
+            QualifiedName.Kind kind
+    ) {
+        QualifiedName result = null;
         if (fqNameProto.hasParentQualifiedName()) {
-            ProtoBuf.QualifiedNameTable.QualifiedName parentProto = qualifiedNames.getQualifiedNames(fqNameProto.getParentQualifiedName());
+            QualifiedName parentProto = qualifiedNames.getQualifiedNames(fqNameProto.getParentQualifiedName());
-            renderFqName(sb, parentProto);
+            if (kind == null || parentProto.getKind() == kind) {
-            sb.append(".");
+                result = renderFqName(sb, parentProto, kind);
+                sb.append(".");
+            }
+            else {
+                result = parentProto;
+            }
         }
         sb.append(simpleNames.getNames(fqNameProto.getShortName()));
-        return sb;
+        return result;
     }
 }

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NestedClassResolver.java

@@ -0,0 +1,14 @@
+package org.jetbrains.jet.descriptors.serialization;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.resolve.name.Name;
+
+public interface NestedClassResolver {
+    @Nullable
+    ClassDescriptor resolveNestedClass(@NotNull ClassDescriptor outerClass, @NotNull Name name);
+
+    @Nullable
+    ClassDescriptor resolveClassObject(@NotNull ClassDescriptor outerClass);
+}

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java

@@ -119,7 +119,7 @@ public class TypeDeserializer {
         TypeConstructor typeConstructor = typeConstructor(constructorProto);
         if (typeConstructor == null) {
             String message = constructorProto.getKind() == ProtoBuf.Type.Constructor.Kind.CLASS
-                             ? nameResolver.getFqName(id).asString()
+                             ? nameResolver.getClassId(id).asSingleFqName().asString()
                              : "Unknown type parameter " + id;
             typeConstructor = ErrorUtils.createErrorType(message).getConstructor();
         }

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorBase;
 import org.jetbrains.jet.lang.descriptors.impl.ReceiverParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TraceUtil;
+import org.jetbrains.jet.lang.resolve.lazy.storage.MemoizedFunctionToNullableImpl;
 import org.jetbrains.jet.lang.resolve.lazy.storage.NullableLazyValue;
 import org.jetbrains.jet.lang.resolve.lazy.storage.NullableLazyValueImpl;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -45,6 +46,12 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
 
     private final NullableLazyValue<ConstructorDescriptor> primaryConstructor;
 
+    private final NestedClassResolver nestedClassResolver;
+    private final NullableLazyValue<ClassDescriptor> classObjectDescriptor;
+
+    private final NestedClassDescriptors nestedClasses;
+    private final NestedClassDescriptors nestedObjects;
+
     private final Name name;
     private final DeclarationDescriptor containingDeclaration;
     private final DeserializedClassTypeConstructor typeConstructor;
@@ -56,7 +63,7 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
     public DeserializedClassDescriptor(
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull NameResolver nameResolver,
-            @NotNull ClassResolver classResolver,
+            @NotNull NestedClassResolver _nestedClassResolver,
             @NotNull ProtoBuf.Class classProto,
             @Nullable TypeDeserializer outerTypeDeserializer
     ) {
@@ -82,6 +89,35 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
                 return computePrimaryConstructor();
             }
         };
+
+        this.nestedClassResolver = _nestedClassResolver;
+        this.classObjectDescriptor = new NullableLazyValueImpl<ClassDescriptor>() {
+            @Override
+            protected ClassDescriptor doCompute() {
+                return computeClassObjectDecriptor();
+            }
+        };
+        this.nestedClasses = new NestedClassDescriptors(stringSet(classProto.getNestedClassNamesList(), nameResolver)) {
+            @Override
+            protected ClassDescriptor resolveNestedClass(@NotNull Name name) {
+                return nestedClassResolver.resolveNestedClass(DeserializedClassDescriptor.this, name);
+            }
+        };
+        this.nestedObjects = new NestedClassDescriptors(stringSet(classProto.getNestedObjectNamesList(), nameResolver)) {
+            @Override
+            protected ClassDescriptor resolveNestedClass(@NotNull Name name) {
+                return nestedClassResolver.resolveNestedClass(DeserializedClassDescriptor.this, name);
+            }
+        };
+    }
+
+    @NotNull
+    private static Set<String> stringSet(@NotNull List<Integer> nameIndices, @NotNull NameResolver nameResolver) {
+        Set<String> result = new HashSet<String>(nameIndices.size());
+        for (Integer index : nameIndices) {
+            result.add(nameResolver.getName(index).getName());
+        }
+        return result;
     }
 
     @NotNull
@@ -180,10 +216,19 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
         return classObjectDescriptor == null ? null : classObjectDescriptor.getDefaultType();
     }
 
+    @Nullable
+    private ClassDescriptor computeClassObjectDecriptor() {
+        if (!classProto.getClassObjectPresent()) {
+            return null;
+        }
+
+        return nestedClassResolver.resolveClassObject(this);
+    }
+
     @Nullable
     @Override
     public ClassDescriptor getClassObjectDescriptor() {
-        return null; // TODO
+        return classObjectDescriptor.compute();
     }
 
     @NotNull
@@ -314,12 +359,54 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
         @Nullable
         @Override
         protected ClassifierDescriptor getClassDescriptor(@NotNull Name name) {
-            return null; // TODO inner classes
+            return classDescriptor.nestedClasses.fun(name);
         }
 
         @Override
         protected void addAllClassDescriptors(@NotNull Collection<DeclarationDescriptor> result) {
-            // TODO inner classes
+            result.addAll(classDescriptor.nestedClasses.getAllDescriptors());
+        }
+
+        @Nullable
+        @Override
+        public ClassDescriptor getObjectDescriptor(@NotNull Name name) {
+            return classDescriptor.nestedObjects.fun(name);
+        }
+
+        @NotNull
+        @Override
+        protected Collection<ClassDescriptor> computeAllObjectDescriptors() {
+            return classDescriptor.nestedObjects.getAllDescriptors();
+        }
+    }
+
+    private abstract static class NestedClassDescriptors extends MemoizedFunctionToNullableImpl<Name, ClassDescriptor> {
+        private final Set<String> declaredNames;
+
+        public NestedClassDescriptors(@NotNull Set<String> declaredNames) {
+            this.declaredNames = declaredNames;
+        }
+
+        @Nullable
+        @Override
+        protected final ClassDescriptor doCompute(@NotNull Name name) {
+            if (!declaredNames.contains(name.getName())) return null;
+
+            return resolveNestedClass(name);
+        }
+
+        protected abstract ClassDescriptor resolveNestedClass(@NotNull Name name);
+
+        @NotNull
+        public Collection<ClassDescriptor> getAllDescriptors() {
+            Collection<ClassDescriptor> result = new ArrayList<ClassDescriptor>(declaredNames.size());
+            for (String name : declaredNames) {
+                ClassDescriptor descriptor = fun(Name.identifier(name));
+                if (descriptor != null) {
+                    result.add(descriptor);
+                }
+            }
+            return result;
         }
     }
 }

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java

@@ -54,6 +54,7 @@ public abstract class DeserializedMemberScope implements JetScope {
     private final MemoizedFunctionToNotNull<Name, Collection<FunctionDescriptor>> functions;
     private final MemoizedFunctionToNotNull<Name, Collection<VariableDescriptor>> properties;
     private final NotNullLazyValue<Collection<DeclarationDescriptor>> allDescriptors;
+    private final NotNullLazyValue<Collection<ClassDescriptor>> objectDescriptors;
 
     public DeserializedMemberScope(
             @NotNull DeclarationDescriptor containingDeclaration,
@@ -85,6 +86,13 @@ public abstract class DeserializedMemberScope implements JetScope {
                 return computeAllDescriptors();
             }
         };
+        this.objectDescriptors = new NotNullLazyValueImpl<Collection<ClassDescriptor>>() {
+            @NotNull
+            @Override
+            protected Collection<ClassDescriptor> doCompute() {
+                return computeAllObjectDescriptors();
+            }
+        };
     }
 
     @NotNull
@@ -164,14 +172,15 @@ public abstract class DeserializedMemberScope implements JetScope {
 
     @Nullable
     @Override
-    public ClassDescriptor getObjectDescriptor(@NotNull Name name) {
+    public abstract ClassDescriptor getObjectDescriptor(@NotNull Name name);
-        return null; // TODO
+
-    }
+    @NotNull
+    protected abstract Collection<ClassDescriptor> computeAllObjectDescriptors();
 
     @NotNull
     @Override
     public Collection<ClassDescriptor> getObjectDescriptors() {
-        return Collections.emptyList(); // TODO
+        return objectDescriptors.compute();
     }
 
     @Nullable

compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java

@@ -17,8 +17,10 @@
 package org.jetbrains.jet.descriptors.serialization;
 
 import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
 import com.google.protobuf.MessageLite;
 import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.util.NullableFunction;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.ConfigurationKind;
@@ -35,6 +37,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 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.lazy.KotlinTestWithEnvironment;
 import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.jet.lang.resolve.lazy.storage.MemoizedFunctionToNullable;
@@ -45,7 +48,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.*;
@@ -53,6 +55,8 @@ import java.util.*;
 
 public abstract class AbstractDescriptorSerializationTest extends KotlinTestWithEnvironment {
 
+    public static final Name TEST_PACKAGE_NAME = Name.identifier("test");
+
     @Override
     protected JetCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY);
@@ -64,7 +68,7 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
                 JetTestUtils.createFile(ktFile.getName(), FileUtil.loadFile(ktFile), getProject())
         ), getEnvironment());
 
-        NamespaceDescriptor testNamespace = moduleDescriptor.getNamespace(FqName.topLevel(Name.identifier("test")));
+        NamespaceDescriptor testNamespace = moduleDescriptor.getNamespace(FqName.topLevel(TEST_PACKAGE_NAME));
         assert testNamespace != null;
 
         JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaDescriptorResolver(
@@ -100,45 +104,61 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
     }
 
     private static NamespaceDescriptor getDeserializedDescriptors(
-            final JavaDescriptorResolver javaDescriptorResolver,
+            JavaDescriptorResolver javaDescriptorResolver,
             List<ClassDescriptor> classes,
             List<CallableMemberDescriptor> callables
     ) throws IOException {
-        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        ByteArrayOutputStream serializedCallables = new ByteArrayOutputStream();
-        serialize(classes, callables, out);
+        Map<ClassDescriptor, byte[]> serializedClasses = Maps.newHashMap();
+        serialize(classes, callables, serializedClasses, serializedCallables);
 
-        InputStream in = new ByteArrayInputStream(out.toByteArray());
+        final Map<String, ClassMetadata> classMetadata = Maps.newHashMap();
 
-        ProtoBuf.SimpleNameTable simpleNames = ProtoBuf.SimpleNameTable.parseDelimitedFrom(in);
+        for (Map.Entry<ClassDescriptor, byte[]> entry : serializedClasses.entrySet()) {
-        ProtoBuf.QualifiedNameTable qualifiedNames = ProtoBuf.QualifiedNameTable.parseDelimitedFrom(in);
+            ClassDescriptor classDescriptor = entry.getKey();
+            byte[] bytes = entry.getValue();
 
-        List<ProtoBuf.Class> classProtos = Lists.newArrayList();
+            ByteArrayInputStream in = new ByteArrayInputStream(bytes);
-        List<ProtoBuf.Callable> callableProtos = Lists.newArrayList();
 
-        for (int i = 0; i < classes.size(); i++) {
+            ProtoBuf.SimpleNameTable simpleNames = ProtoBuf.SimpleNameTable.parseDelimitedFrom(in);
-            ProtoBuf.Class proto = ProtoBuf.Class.parseDelimitedFrom(in);
+            ProtoBuf.QualifiedNameTable qualifiedNames = ProtoBuf.QualifiedNameTable.parseDelimitedFrom(in);
-            classProtos.add(proto);
+            ProtoBuf.Class proto = ProtoBuf.Class.parseFrom(in);
-        }
 
-        for (int i = 0; i < callables.size(); i++) {
+            classMetadata.put(getClassNameString(classDescriptor), new ClassMetadata(simpleNames, qualifiedNames, proto));
-            ProtoBuf.Callable proto = ProtoBuf.Callable.parseDelimitedFrom(in);
-            callableProtos.add(proto);
         }
 
         NamespaceDescriptorImpl namespace = createTestNamespace();
         ClassResolver javaClassResolver = new JavaClassResolver(javaDescriptorResolver);
 
         ClassResolverImpl classResolver = new ClassResolverImpl(
-                javaClassResolver, namespace, simpleNames, qualifiedNames, classProtos
+                javaClassResolver, namespace,
+                new NullableFunction<String, ClassMetadata>() {
+                    @Nullable
+                    @Override
+                    public ClassMetadata fun(String fqName) {
+                        return classMetadata.get(fqName);
+                    }
+                }
         );
 
-        for (ProtoBuf.Class proto : classProtos) {
+        for (ClassDescriptor classDescriptor : classes) {
-            FqName fqName = new FqName("test." + classResolver.getNameResolver().getName(proto.getName()));
+            ClassId classId = new ClassId(DescriptorUtils.getFQName(classDescriptor.getContainingDeclaration()).toSafe(),
-            ClassDescriptor descriptor = classResolver.findClass(fqName);
+                                     FqName.topLevel(classDescriptor.getName()));
-            assert descriptor != null : "Class not loaded: " + fqName;
+            ClassDescriptor descriptor = classResolver.findClass(classId);
+            assert descriptor != null : "Class not loaded: " + classId;
             namespace.getMemberScope().addClassifierDescriptor(descriptor);
         }
 
+        ByteArrayInputStream in = new ByteArrayInputStream(serializedCallables.toByteArray());
+        ProtoBuf.SimpleNameTable simpleNames = ProtoBuf.SimpleNameTable.parseDelimitedFrom(in);
+        ProtoBuf.QualifiedNameTable qualifiedNames = ProtoBuf.QualifiedNameTable.parseDelimitedFrom(in);
+
+        List<ProtoBuf.Callable> callableProtos = Lists.newArrayList();
+        for (int i = 0; i < callables.size(); i++) {
+            ProtoBuf.Callable proto = ProtoBuf.Callable.parseDelimitedFrom(in);
+            callableProtos.add(proto);
+        }
+
         DescriptorDeserializer deserializer =
                 new DescriptorDeserializer((DescriptorDeserializer) null, namespace, new NameResolver(simpleNames, qualifiedNames, classResolver));
         for (ProtoBuf.Callable proto : callableProtos) {
@@ -158,6 +178,13 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
         return namespace;
     }
 
+    private static String getClassNameString(ClassDescriptor classDescriptor) {
+        if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) {
+            return getClassNameString((ClassDescriptor) classDescriptor.getContainingDeclaration()) + "." + JvmAbi.CLASS_OBJECT_CLASS_NAME;
+        }
+        return DescriptorUtils.getFQName(classDescriptor).getFqName();
+    }
+
     private static NamespaceDescriptorImpl createTestNamespace() {
         ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<name>"), JavaBridgeConfiguration.ALL_JAVA_IMPORTS,
                                                                    JavaToKotlinClassMap.getInstance());
@@ -165,30 +192,66 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
                 new NamespaceDescriptorImpl(module, Collections.<AnnotationDescriptor>emptyList(), JetPsiUtil.ROOT_NAMESPACE_NAME);
         module.setRootNamespace(rootNamespace);
         NamespaceDescriptorImpl test =
-                new NamespaceDescriptorImpl(rootNamespace, Collections.<AnnotationDescriptor>emptyList(), Name.identifier("test"));
+                new NamespaceDescriptorImpl(rootNamespace, Collections.<AnnotationDescriptor>emptyList(), TEST_PACKAGE_NAME);
         test.initialize(new WritableScopeImpl(JetScope.EMPTY, test, RedeclarationHandler.DO_NOTHING, "members of test namespace"));
         return test;
     }
 
     public static void serialize(
-            List<ClassDescriptor> classes, List<CallableMemberDescriptor> callables, @NotNull OutputStream out
+            List<ClassDescriptor> classes, List<CallableMemberDescriptor> callables,
+            Map<ClassDescriptor, byte[]> serializedClasses, OutputStream serializedCallables
     ) throws IOException {
+
+        serializeClasses(classes, serializedClasses);
+
         DescriptorSerializer descriptorSerializer = new DescriptorSerializer();
-
         List<MessageLite> messages = Lists.newArrayList();
-        for (ClassDescriptor classDescriptor : classes) {
-            messages.add(descriptorSerializer.classProto(classDescriptor).build());
-
-        }
-
         for (CallableMemberDescriptor callable : callables) {
             messages.add(descriptorSerializer.callableProto(callable).build());
         }
 
-        NameSerializationUtil.serializeNameTable(out, descriptorSerializer.getNameTable());
+        NameSerializationUtil.serializeNameTable(serializedCallables, descriptorSerializer.getNameTable());
 
         for (MessageLite message : messages) {
-            message.writeDelimitedTo(out);
+            message.writeDelimitedTo(serializedCallables);
+        }
+    }
+
+    private static void serializeClasses(Collection<ClassDescriptor> classes, Map<ClassDescriptor, byte[]> serializedClasses) throws IOException {
+        for (ClassDescriptor classDescriptor : classes) {
+            DescriptorSerializer descriptorSerializer = new DescriptorSerializer();
+
+            ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+            ProtoBuf.Class classProto = descriptorSerializer.classProto(classDescriptor).build();
+
+            NameSerializationUtil.serializeNameTable(bytes, descriptorSerializer.getNameTable());
+            classProto.writeTo(bytes);
+
+            serializedClasses.put(classDescriptor, bytes.toByteArray());
+
+            //noinspection unchecked
+            serializeClasses((Collection) classDescriptor.getUnsubstitutedInnerClassesScope().getAllDescriptors(), serializedClasses);
+
+            ClassDescriptor classObjectDescriptor = classDescriptor.getClassObjectDescriptor();
+            if (classObjectDescriptor != null) {
+                serializeClasses(Collections.singletonList(classObjectDescriptor), serializedClasses);
+            }
+        }
+    }
+
+    private static class ClassMetadata {
+        private final ProtoBuf.SimpleNameTable simpleNames;
+        private final ProtoBuf.QualifiedNameTable qualifiedNames;
+        private final ProtoBuf.Class classProto;
+
+        private ClassMetadata(
+                ProtoBuf.SimpleNameTable simpleNames,
+                ProtoBuf.QualifiedNameTable qualifiedNames,
+                ProtoBuf.Class classProto
+        ) {
+            this.simpleNames = simpleNames;
+            this.qualifiedNames = qualifiedNames;
+            this.classProto = classProto;
         }
     }
 
@@ -196,68 +259,64 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
         private final ClassResolver parentResolver;
 
         private final DeclarationDescriptor parentForClasses;
-        private final FqName parentFqName;
+        private final NullableFunction<String, ClassMetadata> classMetadata;
-        private final NameResolver nameResolver;
-        private final Map<Name, ProtoBuf.Class> classProtos;
 
-        private final MemoizedFunctionToNullable<FqName, ClassDescriptor> classes;
+        private final MemoizedFunctionToNullable<ClassId, ClassDescriptor> classes;
 
         public ClassResolverImpl(
                 @NotNull ClassResolver parentResolver,
                 @NotNull DeclarationDescriptor parentForClasses,
-                @NotNull ProtoBuf.SimpleNameTable simpleNames,
+                @NotNull NullableFunction<String, ClassMetadata> classMetadata
-                @NotNull ProtoBuf.QualifiedNameTable qualifiedNames,
-                @NotNull List<ProtoBuf.Class> classProtos
         ) {
             this.parentResolver = parentResolver;
 
             this.parentForClasses = parentForClasses;
-            this.parentFqName = DescriptorUtils.getFQName(parentForClasses).toSafe();
 
-            this.nameResolver = new NameResolver(simpleNames, qualifiedNames, this);
+            this.classMetadata = classMetadata;
-            this.classProtos = toMap(classProtos);
 
-            this.classes = new MemoizedFunctionToNullableImpl<FqName, ClassDescriptor>() {
+            this.classes = new MemoizedFunctionToNullableImpl<ClassId, ClassDescriptor>() {
                 @Nullable
                 @Override
-                protected ClassDescriptor doCompute(@NotNull FqName fqName) {
+                protected ClassDescriptor doCompute(@NotNull ClassId classId) {
-                    return resolveClass(fqName);
+                    return resolveClass(ClassResolverImpl.this.parentForClasses, classId);
                 }
             };
         }
 
-        @NotNull
-        private Map<Name, ProtoBuf.Class> toMap(@NotNull List<ProtoBuf.Class> classProtos) {
-            Map<Name, ProtoBuf.Class> map = new HashMap<Name, ProtoBuf.Class>(classProtos.size());
-            for (ProtoBuf.Class classProto : classProtos) {
-                map.put(nameResolver.getName(classProto.getName()), classProto);
-            }
-            return map;
-        }
-
-        @NotNull
-        public NameResolver getNameResolver() {
-            return nameResolver;
-        }
-
         @Nullable
-        private ClassDescriptor resolveClass(@NotNull FqName fqName) {
+        private ClassDescriptor resolveClass(
-            if (!parentFqName.equals(fqName.parent())) {
+                @NotNull DeclarationDescriptor containingDeclaration,
-                return parentResolver.findClass(fqName);
+                @NotNull final ClassId classId
+        ) {
+            FqName fqName = classId.asSingleFqName();
+
+            ClassMetadata classMetadata = this.classMetadata.fun(fqName.getFqName());
+            if (classMetadata == null) {
+                return parentResolver.findClass(classId);
             }
 
-            ProtoBuf.Class classProto = classProtos.get(fqName.shortName());
+            NestedClassResolver nestedClassResolver = new NestedClassResolver() {
-            if (classProto == null) {
+                @Nullable
-                return parentResolver.findClass(fqName);
+                @Override
-            }
+                public ClassDescriptor resolveNestedClass(@NotNull ClassDescriptor outerClass, @NotNull Name name) {
+                    return resolveClass(outerClass, classId.createNestedClassId(name));
+                }
 
-            return new DeserializedClassDescriptor(parentForClasses, nameResolver, this, classProto, null);
+                @Nullable
+                @Override
+                public ClassDescriptor resolveClassObject(@NotNull ClassDescriptor outerClass) {
+                    return resolveClass(outerClass, classId.createNestedClassId(Name.identifier(JvmAbi.CLASS_OBJECT_CLASS_NAME)));
+                }
+            };
+
+            NameResolver nameResolver = new NameResolver(classMetadata.simpleNames, classMetadata.qualifiedNames, this);
+            return new DeserializedClassDescriptor(containingDeclaration, nameResolver, nestedClassResolver, classMetadata.classProto, null);
         }
 
         @Nullable
         @Override
-        public ClassDescriptor findClass(@NotNull FqName fqName) {
+        public ClassDescriptor findClass(@NotNull ClassId classId) {
-            return classes.fun(fqName);
+            return classes.fun(classId);
         }
     }
 
@@ -270,24 +329,31 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
 
         @Nullable
         @Override
-        public ClassDescriptor findClass(@NotNull FqName fqName) {
+        public ClassDescriptor findClass(@NotNull ClassId classId) {
-            ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(fqName);
+            ClassDescriptor javaClassDescriptor = javaDescriptorResolver.resolveClass(classId.asSingleFqName());
-            if (classDescriptor != null) {
+            if (javaClassDescriptor != null) {
-                return classDescriptor;
+                return javaClassDescriptor;
             }
-            FqName current = fqName;
+            NamespaceDescriptor packageDescriptor = getNamespace(classId.getPackageFqName());
-            while (!current.isRoot()) {
+            if (packageDescriptor == null) {
-                NamespaceDescriptor namespace = getNamespace(current);
+                throw new IllegalStateException("Java package not found: " + classId.getPackageFqName() + " for " + classId);
-                if (namespace != null) {
+            }
-                    ClassDescriptor classifier = (ClassDescriptor) namespace.getMemberScope().getClassifier(current.shortName());
+
-                    if (classifier == null) {
+            JetScope scope = packageDescriptor.getMemberScope();
-                        throw new IllegalStateException("Class not found: " + fqName);
+            for (Iterator<Name> iterator = classId.getRelativeClassName().pathSegments().iterator(); iterator.hasNext(); ) {
-                    }
+                Name name = iterator.next();
-                    return classifier;
+                ClassifierDescriptor classifier = scope.getClassifier(name);
+                if (classifier == null) {
+                    throw new IllegalStateException("Class not found: " + classId);
                 }
-                current = current.parent();
+                ClassDescriptor classDescriptor = (ClassDescriptor) classifier;
+                if (!iterator.hasNext()) {
+                    return classDescriptor;
+                }
+                scope = classDescriptor.getUnsubstitutedInnerClassesScope();
             }
-            throw new IllegalStateException("Class not found: " + fqName);
+
+            throw new IllegalStateException("Class not found: " + classId);
         }
 
         @Nullable