Straightforward logic for deserialization descriptors in DeserializedDescriptorResolver

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java

@@ -27,15 +27,14 @@ 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.descriptors.serialization.descriptors.DeserializedClassDescriptor;
 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.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;
@@ -92,6 +91,14 @@ public final class DeserializedDescriptorResolver {
 
     private JavaClassResolver javaClassResolver;
 
+    private DescriptorFinder javaDescriptorFinder = new DescriptorFinder() {
+        @Nullable
+        @Override
+        public ClassDescriptor findClass(@NotNull ClassId classId) {
+            return javaClassResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName()));
+        }
+    };
+
     @Inject
     public void setJavaNamespaceResolver(JavaNamespaceResolver javaNamespaceResolver) {
         this.javaNamespaceResolver = javaNamespaceResolver;
@@ -153,11 +160,14 @@ public final class DeserializedDescriptorResolver {
             @NotNull ClassOrNamespaceDescriptor containingDeclaration
     ) {
         ClassId classId = ClassId.fromFqNameAndContainingDeclaration(fqName, containingDeclaration);
-        AbstractDescriptorFinder descriptorFinder =
+
-                new DeserializedDescriptorFinder(storageManager, DUMMY_ANNOTATION_DESERIALIZER, classId, classData);
+        DeclarationDescriptor owner = classId.isTopLevelClass()
-        ClassDescriptor classDescriptor = descriptorFinder.findClassInternally(classId);
+                                  ? javaNamespaceResolver.resolveNamespace(classId.getPackageFqName(), INCLUDE_KOTLIN)
-        assert classDescriptor != null : "Could not correctly deserialize class " + fqName.asString();
+                                  : javaClassResolver.resolveClass(kotlinFqNameToJavaFqName(classId.getOuterClassId().asSingleFqName()));
-        return classDescriptor;
+        assert owner != null : "No owner found for " + classId;
+
+        return new DeserializedClassDescriptor(classId, storageManager, owner, classData.getNameResolver(),
+                                               DUMMY_ANNOTATION_DESERIALIZER, javaDescriptorFinder, classData.getClassProto(), null);
     }
 
     @Nullable
@@ -229,50 +239,4 @@ public final class DeserializedDescriptorResolver {
         }
         return FqName.fromSegments(correctedSegments);
     }
-
-    public class DeserializedDescriptorFinder extends AbstractDescriptorFinder {
-        @NotNull
-        private final ClassId classID;
-        @NotNull
-        private final ClassData classData;
-
-        public DeserializedDescriptorFinder(
-                @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;
-        }
-
-        @Nullable
-        @Override
-        protected ClassDescriptor resolveClassExternally(@NotNull ClassId classId) {
-            return javaClassResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName()));
-        }
-
-        @Override
-        protected void classDescriptorCreated(@NotNull ClassDescriptor classDescriptor) {
-            //nothing to do here
-        }
-    }
 }

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

@@ -34,7 +34,10 @@ public abstract class AbstractDescriptorFinder implements DescriptorFinder {
     private final MemoizedFunctionToNullable<ClassId, ClassDescriptor> findClass;
     private final AnnotationDeserializer annotationDeserializer;
 
-    public AbstractDescriptorFinder(@NotNull final StorageManager storageManager, @NotNull AnnotationDeserializer annotationDeserializer) {
+    public AbstractDescriptorFinder(
+            @NotNull final StorageManager storageManager,
+            @NotNull AnnotationDeserializer annotationDeserializer
+    ) {
         this.annotationDeserializer = annotationDeserializer;
 
         this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function<ClassId, ClassDescriptor>() {
@@ -64,16 +67,6 @@ public abstract class AbstractDescriptorFinder implements DescriptorFinder {
     @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);
     }
 
@@ -83,11 +76,5 @@ public abstract class AbstractDescriptorFinder implements DescriptorFinder {
     @NotNull
     protected abstract DeclarationDescriptor getPackage(@NotNull FqName fqName);
 
-    @Nullable
-    protected ClassDescriptor resolveClassExternally(@NotNull ClassId classId) {
-        //TODO: decide whether it is ok to provide default implementation
-        return null;
-    }
-
     protected abstract void classDescriptorCreated(@NotNull ClassDescriptor classDescriptor);
 }