Deserializer: use module to search for dependencies in TypeDeserializer

2014-06-16 15:00:57 +04:00
parent a66353dbc4
commit 7ee7047753
11 changed files with 83 additions and 17 deletions
@@ -92,7 +92,7 @@ public class InjectorForJavaDescriptorResolver {
        this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
        this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
        this.constantDescriptorLoader = new ConstantDescriptorLoader();
-        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, getModule(), javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
        this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);

        this.javaClassFinder.setProject(project);
@@ -160,7 +160,7 @@ public class InjectorForLazyResolveWithJava {
        this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
        this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
        this.constantDescriptorLoader = new ConstantDescriptorLoader();
-        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, getModule(), javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
        this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);

        this.resolveSession.setAnnotationResolve(annotationResolver);
@@ -162,7 +162,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
        this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider);
        this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
        this.constantDescriptorLoader = new ConstantDescriptorLoader();
-        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
+        this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, getModuleDescriptor(), javaDescriptorFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
        this.bodyResolver = new BodyResolver();
        this.annotationResolver = new AnnotationResolver();
        this.callResolver = new CallResolver();
@@ -36,6 +36,7 @@ import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
+import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -43,6 +44,7 @@ import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;

 import java.io.File;
 import java.io.IOException;
@@ -91,6 +93,8 @@ public final class LoadDescriptorUtil {
        JetCoreEnvironment jetCoreEnvironment = JetCoreEnvironment.createForTests(disposable, configuration);
        BindingTraceContext trace = new BindingTraceContext();
        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace);
+        injector.getModule().addFragmentProvider(DependencyKind.BUILT_INS,
+                                                 KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
        PackageViewDescriptor packageView = injector.getModule().getPackage(TEST_PACKAGE_FQNAME);
        assert packageView != null;

@@ -19,11 +19,15 @@ package org.jetbrains.jet.lang.resolve.kotlin
 import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext
 import org.jetbrains.jet.storage.StorageManager
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
+

 public class DeserializationGlobalContextForJava(
        storageManager: StorageManager,
+        moduleDescriptor: ModuleDescriptor,
        descriptorFinder: JavaDescriptorFinder,
        annotationLoader: AnnotationDescriptorLoader,
        constantLoader: ConstantDescriptorLoader,
        packageFragmentProvider: LazyJavaPackageFragmentProvider
-) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader, constantLoader, packageFragmentProvider)
+) : DeserializationGlobalContext(storageManager, moduleDescriptor, descriptorFinder, annotationLoader,
+                                 constantLoader, packageFragmentProvider)
@@ -44,15 +44,17 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {
    private final DeserializedPackageMemberScope members;
    private final NameResolver nameResolver;
    private final PackageFragmentProvider packageFragmentProvider;
+    private final ModuleDescriptor module;

    public BuiltinsPackageFragment(@NotNull StorageManager storageManager, @NotNull ModuleDescriptor module) {
        super(module, KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME);
+        this.module = module;
        nameResolver = NameSerializationUtil.deserializeNameResolver(getStream(BuiltInsSerializationUtil.getNameTableFilePath(getFqName())));

        packageFragmentProvider = new BuiltinsPackageFragmentProvider();

        DeserializationContext context = new DeserializationContext(
-                storageManager, new BuiltInsDescriptorFinder(storageManager),
+                storageManager, module, new BuiltInsDescriptorFinder(storageManager),
                // TODO: support annotations
                AnnotationLoader.UNSUPPORTED, ConstantLoader.UNSUPPORTED, packageFragmentProvider,
                nameResolver
@@ -122,7 +124,7 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {

        public BuiltInsDescriptorFinder(@NotNull StorageManager storageManager) {
            // TODO: support annotations
-            super(storageManager, AnnotationLoader.UNSUPPORTED, ConstantLoader.UNSUPPORTED, packageFragmentProvider);
+            super(storageManager, module, AnnotationLoader.UNSUPPORTED, ConstantLoader.UNSUPPORTED, packageFragmentProvider);

            classNames = storageManager.createLazyValue(new Function0<Collection<Name>>() {
                @Override
@@ -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
@@ -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) {
@@ -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)

@@ -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
+}
@@ -148,11 +148,12 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
        }
    }

-    val deserializationContext = DeserializationGlobalContext(storageManager, descriptorFinder, annotationLoader,
+    val moduleDescriptor = ErrorUtils.getErrorModule()
+    val deserializationContext = DeserializationGlobalContext(storageManager, moduleDescriptor, descriptorFinder, annotationLoader,
                                                              constantLoader, packageFragmentProvider)

    private fun createDummyPackageFragment(fqName: FqName): MutablePackageFragmentDescriptor {
-        return MutablePackageFragmentDescriptor(ErrorUtils.getErrorModule(), fqName)
+        return MutablePackageFragmentDescriptor(moduleDescriptor, fqName)
    }

    private fun resolveClassByClassId(classId: ClassId): ClassDescriptor? {