Deserializer: use module to search for dependencies in TypeDeserializer

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

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.Nullable;
 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.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
 import org.jetbrains.jet.storage.MemoizedFunctionToNullable;
 import org.jetbrains.jet.storage.StorageManager;
@@ -31,12 +32,13 @@ public abstract class AbstractDescriptorFinder implements DescriptorFinder {
 
     public AbstractDescriptorFinder(
             @NotNull StorageManager storageManager,
+            @NotNull ModuleDescriptor moduleDescriptor,
             @NotNull AnnotationLoader annotationLoader,
             @NotNull ConstantLoader constantLoader,
             @NotNull PackageFragmentProvider packageFragmentProvider
     ) {
         final DeserializationGlobalContext deserializationGlobalContext =
-                new DeserializationGlobalContext(storageManager, this, annotationLoader, constantLoader,
+                new DeserializationGlobalContext(storageManager, moduleDescriptor, this, annotationLoader, constantLoader,
                                                  packageFragmentProvider);
         this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function1<ClassId, ClassDescriptor>() {
             @Override

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

@@ -146,7 +146,7 @@ public class TypeDeserializer {
     @Nullable
     private ClassDescriptor computeClassDescriptor(int fqNameIndex) {
         ClassId classId = context.getNameResolver().getClassId(fqNameIndex);
-        return context.getDescriptorFinder().findClass(classId);
+        return SerializationPackage.findClassAcrossModuleDependencies(context.getModuleDescriptor(), classId);
     }
 
     private List<TypeProjection> typeArguments(List<ProtoBuf.Type.Argument> protos) {

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

@@ -28,16 +28,26 @@ 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.descriptors.ConstantLoader
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor
+import org.jetbrains.jet.descriptors.serialization.ClassId
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor
+import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe
+import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.lang.resolve.name.SpecialNames
+import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor
 
 public open class DeserializationGlobalContext(
         public val storageManager: StorageManager,
+        public val moduleDescriptor: ModuleDescriptor,
         public val descriptorFinder: DescriptorFinder,
         public val annotationLoader: AnnotationLoader,
         public val constantLoader: ConstantLoader,
         public val packageFragmentProvider: PackageFragmentProvider
 ) {
     public fun withNameResolver(nameResolver: NameResolver): DeserializationContext {
-        return DeserializationContext(storageManager, descriptorFinder, annotationLoader,
+        return DeserializationContext(storageManager, moduleDescriptor, descriptorFinder, annotationLoader,
                                       constantLoader, packageFragmentProvider, nameResolver)
     }
 }
@@ -45,12 +55,13 @@ public open class DeserializationGlobalContext(
 
 public open class DeserializationContext(
         storageManager: StorageManager,
+        moduleDescriptor: ModuleDescriptor,
         descriptorFinder: DescriptorFinder,
         annotationLoader: AnnotationLoader,
         constantLoader: ConstantLoader,
         packageFragmentProvider: PackageFragmentProvider,
         public val nameResolver: NameResolver
-) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader,
+) : DeserializationGlobalContext(storageManager, moduleDescriptor, descriptorFinder, annotationLoader,
                                  constantLoader, packageFragmentProvider) {
     fun withTypes(containingDeclaration: DeclarationDescriptor): DeserializationContextWithTypes {
         val typeDeserializer = TypeDeserializer(this, null, "Deserializer for ${containingDeclaration.getName()}",
@@ -59,10 +70,9 @@ public open class DeserializationContext(
     }
 
     fun withTypes(containingDeclaration: DeclarationDescriptor, typeDeserializer: TypeDeserializer): DeserializationContextWithTypes {
-        return DeserializationContextWithTypes(storageManager, descriptorFinder, annotationLoader,
-                                               constantLoader, packageFragmentProvider,
-                                               nameResolver, containingDeclaration,
-                                               typeDeserializer)
+        return DeserializationContextWithTypes(storageManager, moduleDescriptor, descriptorFinder, annotationLoader,
+                                               constantLoader, packageFragmentProvider, 
+                                               nameResolver, containingDeclaration, typeDeserializer)
     }
 
 }
@@ -70,6 +80,7 @@ public open class DeserializationContext(
 
 class DeserializationContextWithTypes(
         storageManager: StorageManager,
+        moduleDescriptor: ModuleDescriptor,
         descriptorFinder: DescriptorFinder,
         annotationLoader: AnnotationLoader,
         constantLoader: ConstantLoader,
@@ -77,7 +88,7 @@ class DeserializationContextWithTypes(
         nameResolver: NameResolver,
         val containingDeclaration: DeclarationDescriptor,
         val typeDeserializer: TypeDeserializer
-) : DeserializationContext(storageManager, descriptorFinder, annotationLoader,
+) : DeserializationContext(storageManager, moduleDescriptor, descriptorFinder, annotationLoader,
                            constantLoader, packageFragmentProvider, nameResolver) {
     val deserializer: MemberDeserializer = MemberDeserializer(this)
 

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

@@ -0,0 +1,42 @@
+/*
+ * 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.lang.descriptors.ClassDescriptor
+import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.lang.resolve.name.SpecialNames
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
+
+private fun findInnerClass(classDescriptor: ClassDescriptor, name: Name): ClassDescriptor? {
+    return if (SpecialNames.isClassObjectName(name)) {
+        classDescriptor.getClassObjectDescriptor()
+    }
+    else {
+        classDescriptor.getUnsubstitutedInnerClassesScope().getClassifier(name) as? ClassDescriptor
+    }
+}
+
+fun ModuleDescriptor.findClassAcrossModuleDependencies(classId: ClassId): ClassDescriptor? {
+    val packageViewDescriptor = getPackage(classId.getPackageFqName()) ?: return null
+    val segments = classId.getRelativeClassName().pathSegments()
+    val topLevelClass = packageViewDescriptor.getMemberScope().getClassifier(segments.first!!) as? ClassDescriptor ?: return null
+    var result = topLevelClass
+    for (name in segments.subList(1, segments.size())) {
+        result = findInnerClass(result, name) ?: return null
+    }
+    return result
+}