Remove NestedClassResolver class

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

@@ -26,27 +26,17 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.resolve.lazy.storage.MemoizedFunctionToNullable;
 import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
 
 import static org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager.ReferenceKind.STRONG;
 
 public abstract class AbstractClassResolver implements ClassResolver {
 
-    private final NestedClassResolver nestedClassResolver;
     private final MemoizedFunctionToNullable<ClassId, ClassDescriptor> findClass;
     private final AnnotationDeserializer annotationDeserializer;
 
     public AbstractClassResolver(@NotNull final StorageManager storageManager, @NotNull AnnotationDeserializer annotationDeserializer) {
         this.annotationDeserializer = annotationDeserializer;
 
-        this.nestedClassResolver = new NestedClassResolver() {
-            @Nullable
-            @Override
-            public ClassDescriptor resolveNestedClass(@NotNull ClassDescriptor outerClass, @NotNull Name name) {
-                return findClass(getClassId(outerClass).createNestedClassId(name));
-            }
-        };
-
         this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function<ClassId, ClassDescriptor>() {
             @Override
             public ClassDescriptor fun(ClassId classId) {
@@ -63,9 +53,8 @@ public abstract class AbstractClassResolver implements ClassResolver {
 
                 AbstractClassResolver _this = AbstractClassResolver.this;
                 ClassDescriptor classDescriptor = new DeserializedClassDescriptor(
-                        storageManager, owner, classData.getNameResolver(), _this.annotationDeserializer,
+                        classId, storageManager, owner, classData.getNameResolver(),
-                        _this, nestedClassResolver, classProto, null
+                        _this.annotationDeserializer, _this, classProto, null);
-                );
                 classDescriptorCreated(classDescriptor);
                 return classDescriptor;
             }

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

@@ -19,14 +19,12 @@ package org.jetbrains.jet.descriptors.serialization;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
-import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.Variance;
 
 import java.util.ArrayList;
@@ -115,14 +113,6 @@ public class DescriptorDeserializer {
         return create(storageManager, childTypeDeserializer, descriptor, nameResolver, annotationDeserializer);
     }
 
-    @NotNull
-    public ClassDescriptor loadClass(@NotNull ProtoBuf.Class proto, @NotNull NestedClassResolver nestedClassResolver) {
-        return new DeserializedClassDescriptor(
-                storageManager, containingDeclaration, getNameResolver(), annotationDeserializer,
-                typeDeserializer.getClassResolver(), nestedClassResolver, proto, typeDeserializer
-        );
-    }
-
     @NotNull
     public CallableMemberDescriptor loadCallable(@NotNull Callable proto) {
         Callable.CallableKind callableKind = Flags.CALLABLE_KIND.get(proto.getFlags());

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

@@ -1,11 +0,0 @@
-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);
-}

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

@@ -45,6 +45,7 @@ import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
 
 public class DeserializedClassDescriptor extends ClassDescriptorBase implements ClassDescriptor {
 
+    private final ClassId classId;
     private final ProtoBuf.Class classProto;
     private final TypeDeserializer typeDeserializer;
     private final DescriptorDeserializer deserializer;
@@ -56,7 +57,6 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
     private final AnnotationDeserializer annotationDeserializer;
     private final NotNullLazyValue<List<AnnotationDescriptor>> annotations;
 
-    private final NestedClassResolver nestedClassResolver;
     private final NullableLazyValue<ClassDescriptor> classObjectDescriptor;
 
     private final NestedClassDescriptors nestedClasses;
@@ -70,18 +70,21 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
     private final ClassKind kind;
     private final boolean isInner;
     private final InnerClassesScopeWrapper innerClassesScope;
+    private final ClassResolver classResolver;
 
     public DeserializedClassDescriptor(
+            @NotNull ClassId classId,
             @NotNull StorageManager storageManager,
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull NameResolver nameResolver,
             @NotNull AnnotationDeserializer annotationResolver,
-            @NotNull ClassResolver classResolver,
+            @NotNull final ClassResolver classResolver,
-            @NotNull NestedClassResolver _nestedClassResolver,
             @NotNull ProtoBuf.Class classProto,
             @Nullable TypeDeserializer outerTypeDeserializer
     ) {
+        this.classId = classId;
         this.classProto = classProto;
+        this.classResolver = classResolver;
         this.name = nameResolver.getName(classProto.getName());
 
         TypeDeserializer notNullTypeDeserializer = new TypeDeserializer(storageManager, outerTypeDeserializer, nameResolver, classResolver,
@@ -119,7 +122,6 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
             }
         });
 
-        this.nestedClassResolver = _nestedClassResolver;
         this.classObjectDescriptor = storageManager.createNullableLazyValue(new Computable<ClassDescriptor>() {
             @Override
             public ClassDescriptor compute() {
@@ -129,13 +131,13 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
         this.nestedClasses = new NestedClassDescriptors(storageManager, stringSet(classProto.getNestedClassNameList(), nameResolver)) {
             @Override
             protected ClassDescriptor resolveNestedClass(@NotNull Name name) {
-                return nestedClassResolver.resolveNestedClass(DeserializedClassDescriptor.this, name);
+                return classResolver.findClass(DeserializedClassDescriptor.this.classId.createNestedClassId(name));
             }
         };
         this.nestedObjects = new NestedClassDescriptors(storageManager, stringSet(classProto.getNestedObjectNameList(), nameResolver)) {
             @Override
             protected ClassDescriptor resolveNestedClass(@NotNull Name name) {
-                return nestedClassResolver.resolveNestedClass(DeserializedClassDescriptor.this, name);
+                return classResolver.findClass(DeserializedClassDescriptor.this.classId.createNestedClassId(name));
             }
         };
     }
@@ -268,7 +270,7 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
             return classObject;
         }
 
-        return nestedClassResolver.resolveNestedClass(this, getClassObjectName(getName()));
+        return classResolver.findClass(classId.createNestedClassId(getClassObjectName(getName())));
     }
 
     @NotNull
@@ -294,7 +296,8 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
 
     private void createEnumEntry(@NotNull MutableClassDescriptor enumClassObject, @NotNull Name name) {
         PropertyDescriptorImpl property = new PropertyDescriptorImpl(enumClassObject, Collections.<AnnotationDescriptor>emptyList(),
-                 Modality.FINAL, Visibilities.PUBLIC, false, name, CallableMemberDescriptor.Kind.DECLARATION);
+                                                                     Modality.FINAL, Visibilities.PUBLIC, false, name,
+                                                                     CallableMemberDescriptor.Kind.DECLARATION);
         property.setType(getDefaultType(), Collections.<TypeParameterDescriptor>emptyList(),
                          enumClassObject.getThisAsReceiverParameter(), NO_RECEIVER_PARAMETER);
 

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

@@ -149,7 +149,7 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
 
         for (ClassDescriptor classDescriptor : classes) {
             ClassId classId = new ClassId(DescriptorUtils.getFQName(classDescriptor.getContainingDeclaration()).toSafe(),
-                                     FqNameUnsafe.topLevel(classDescriptor.getName()));
+                                          FqNameUnsafe.topLevel(classDescriptor.getName()));
             ClassDescriptor descriptor = classResolver.findClass(classId);
             assert descriptor != null : "Class not loaded: " + classId;
             if (descriptor.getKind().isObject()) {
@@ -211,7 +211,7 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
 
     private static NamespaceDescriptorImpl createTestNamespace() {
         ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<name>"), JavaBridgeConfiguration.ALL_JAVA_IMPORTS,
-                                                                   JavaToKotlinClassMap.getInstance());
+                                                               JavaToKotlinClassMap.getInstance());
         NamespaceDescriptorImpl rootNamespace =
                 new NamespaceDescriptorImpl(module, Collections.<AnnotationDescriptor>emptyList(), JetPsiUtil.ROOT_NAMESPACE_NAME);
         module.setRootNamespace(rootNamespace);
@@ -241,7 +241,8 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
         }
     }
 
-    private static void serializeClasses(Collection<ClassDescriptor> classes, Map<ClassDescriptor, byte[]> serializedClasses) throws IOException {
+    private static void serializeClasses(Collection<ClassDescriptor> classes, Map<ClassDescriptor, byte[]> serializedClasses)
+            throws IOException {
         for (ClassDescriptor classDescriptor : classes) {
             DescriptorSerializer descriptorSerializer = new DescriptorSerializer();
 
@@ -315,7 +316,7 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
         @Nullable
         private ClassDescriptor resolveClass(
                 @NotNull DeclarationDescriptor containingDeclaration,
-                @NotNull final ClassId classId
+                @NotNull ClassId classId
         ) {
             FqNameUnsafe fqName = classId.asSingleFqName();
 
@@ -324,17 +325,10 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
                 return parentResolver.findClass(classId);
             }
 
-            NestedClassResolver nestedClassResolver = new NestedClassResolver() {
-                @Nullable
-                @Override
-                public ClassDescriptor resolveNestedClass(@NotNull ClassDescriptor outerClass, @NotNull Name name) {
-                    return findClass(classId.createNestedClassId(name));
-                }
-            };
-
             NameResolver nameResolver = new NameResolver(classMetadata.simpleNames, classMetadata.qualifiedNames);
-            return new DeserializedClassDescriptor(new LockBasedStorageManager(), containingDeclaration, nameResolver,
+            return new DeserializedClassDescriptor(classId, new LockBasedStorageManager(), containingDeclaration, nameResolver,
-                    DeserializedDescriptorResolver.DUMMY_ANNOTATION_DESERIALIZER, this, nestedClassResolver, classMetadata.classProto, null);
+                                                   DeserializedDescriptorResolver.DUMMY_ANNOTATION_DESERIALIZER, this,
+                                                   classMetadata.classProto, null);
         }
 
         @Nullable