Merge DeserializationGlobalContext with DeserializationComponents

2014-11-20 19:28:04 +03:00
parent aa1fa7063e
commit cb5c21e831
10 changed files with 46 additions and 61 deletions
@@ -126,7 +126,8 @@ public enum TopDownAnalyzerFacadeForJVM {

                    additionalProviders.add(
                            new IncrementalPackageFragmentProvider(
-                                    files, module, topDownAnalysisParameters.getStorageManager(), injector.getDeserializationGlobalContextForJava(),
+                                    files, module, topDownAnalysisParameters.getStorageManager(),
+                                    injector.getDeserializationGlobalContextForJava().getComponents(),
                                    incrementalCache, moduleId, injector.getJavaDescriptorResolver()
                            )
                    );
@@ -27,28 +27,24 @@ import org.jetbrains.jet.lang.descriptors.impl.PackageFragmentDescriptorImpl
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.storage.StorageManager
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope
-import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil
+import org.jetbrains.jet.descriptors.serialization.*
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver
 import org.jetbrains.jet.utils.addToStdlib.singletonOrEmptyList
 import org.jetbrains.jet.storage.NotNullLazyValue
-import org.jetbrains.jet.descriptors.serialization.ProtoBuf
 import org.jetbrains.jet.lang.resolve.kotlin.PackagePartClassUtils
-import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf
 import org.jetbrains.jet.lang.resolve.java.JvmClassName
-import org.jetbrains.jet.descriptors.serialization.PackageData
-import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava
 import org.jetbrains.jet.lang.resolve.kotlin.incremental.cache.IncrementalCache
 import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.descriptors.serialization.context.DeserializationComponents

 public class IncrementalPackageFragmentProvider(
        sourceFiles: Collection<JetFile>,
        val module: ModuleDescriptor,
        val storageManager: StorageManager,
-        val deserializationContext: DeserializationGlobalContextForJava,
+        val deserializationComponents: DeserializationComponents,
        val incrementalCache: IncrementalCache,
        val moduleId: String,
        val javaDescriptorResolver: JavaDescriptorResolver
-
 ) : PackageFragmentProvider {

    val packagePartsToNotLoadFromCache = (
@@ -115,7 +111,7 @@ public class IncrementalPackageFragmentProvider(
        private inner class IncrementalPackageScope(val packageData: PackageData) : DeserializedPackageMemberScope(
                this@IncrementalPackageFragment,
                packageData.getPackageProto(),
-                deserializationContext.withNameResolver(packageData.getNameResolver()),
+                deserializationComponents.createContext(packageData.getNameResolver()),
                { listOf() }
        ) {
            override fun filteredMemberProtos(allMemberProtos: Collection<ProtoBuf.Callable>): Collection<ProtoBuf.Callable> {
@@ -16,12 +16,13 @@

 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
 import org.jetbrains.jet.descriptors.serialization.context.DeserializationComponents

+// This class is needed only for easier injection: exact types of needed components are specified in the constructor here.
+// Otherwise injector generator is not smart enough to deduce, for example, which package fragment provider DeserializationComponents needs
 public class DeserializationGlobalContextForJava(
        storageManager: StorageManager,
        moduleDescriptor: ModuleDescriptor,
@@ -29,9 +30,9 @@ public class DeserializationGlobalContextForJava(
        annotationLoader: AnnotationDescriptorLoader,
        constantLoader: ConstantDescriptorLoader,
        packageFragmentProvider: LazyJavaPackageFragmentProvider
-) : DeserializationGlobalContext(
-        DeserializationComponents(
+) {
+        val components = DeserializationComponents(
                storageManager, moduleDescriptor, classDataFinder, annotationLoader, constantLoader, packageFragmentProvider,
                JavaFlexibleTypeCapabilitiesDeserializer
        )
-)
+}
@@ -54,7 +54,9 @@ public final class DeserializedDescriptorResolver {
    public ClassDescriptor resolveClass(@NotNull KotlinJvmBinaryClass kotlinClass) {
        String[] data = readData(kotlinClass, CLASS);
        if (data != null) {
-            return context.getClassDeserializer().deserializeClass(kotlinClass.getClassId(), JavaProtoBufUtil.readClassDataFrom(data));
+            return context.getComponents().getClassDeserializer().deserializeClass(
+                    kotlinClass.getClassId(), JavaProtoBufUtil.readClassDataFrom(data)
+            );
        }
        return null;
    }
@@ -65,7 +67,7 @@ public final class DeserializedDescriptorResolver {
        if (data != null) {
            //all classes are included in java scope
            return DescriptorsPackage.DeserializedPackageMemberScope(
-                    descriptor, JavaProtoBufUtil.readPackageDataFrom(data), context,
+                    descriptor, JavaProtoBufUtil.readPackageDataFrom(data), context.getComponents(),
                    new Function0<Collection<Name>>() {
                        @Override
                        public Collection<Name> invoke() {
@@ -48,7 +48,7 @@ class BuiltinsPackageFragment(storageManager: StorageManager, module: ModuleDesc
                DeserializationComponents(
                        storageManager, module, BuiltInsClassDataFinder(), AnnotationLoader.UNSUPPORTED, // TODO: support annotations
                        ConstantLoader.UNSUPPORTED, provider, FlexibleTypeCapabilitiesDeserializer.ThrowException
-                ).createContext().withNameResolver(nameResolver),
+                ).createContext(nameResolver),
                { readClassNames() }
        )

@@ -18,15 +18,10 @@ package org.jetbrains.jet.descriptors.serialization

 import org.jetbrains.jet.lang.descriptors.ClassDescriptor
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor
-import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext
-import kotlin.properties.Delegates
 import org.jetbrains.jet.lang.resolve.name.ClassId
 import org.jetbrains.jet.descriptors.serialization.context.DeserializationComponents

-public class ClassDeserializer(components: DeserializationComponents) {
-    // This should have been a constructor parameter, but this class and the context depend circularly on each other
-    var globalContext: DeserializationGlobalContext by Delegates.notNull()
-
+public class ClassDeserializer(private val components: DeserializationComponents) {
    private val classes: (ClassKey) -> DeserializedClassDescriptor? = components.storageManager.createMemoizedFunctionWithNullableValues {
        (key: ClassKey) ->
        val classId = key.classId
@@ -35,8 +30,8 @@ public class ClassDeserializer(components: DeserializationComponents) {
            val outerClassContext =
                    if (classId.isTopLevelClass()) null
                    else classes(ClassKey(classId.getOuterClassId(), null))?.context
-            val context = outerClassContext ?: globalContext
-            DeserializedClassDescriptor(context.withNameResolver(classData.getNameResolver()), classData.getClassProto())
+            // TODO: use outerClassContext
+            DeserializedClassDescriptor(components.createContext(classData.getNameResolver()), classData.getClassProto())
        }
        else {
            null
@@ -41,46 +41,31 @@ public class DeserializationComponents(
        public val packageFragmentProvider: PackageFragmentProvider,
        public val flexibleTypeCapabilitiesDeserializer: FlexibleTypeCapabilitiesDeserializer
 ) {
-    public fun createContext(): DeserializationGlobalContext = DeserializationGlobalContext(this)
-}
+    public val classDeserializer: ClassDeserializer = ClassDeserializer(this)

-public open class DeserializationGlobalContext(
-        public val components: DeserializationComponents,
-        public val classDeserializer: ClassDeserializer = ClassDeserializer(components)
-) {
-    {
-        classDeserializer.globalContext = this
-    }
+    public fun deserializeClass(classId: ClassId): ClassDescriptor? = classDeserializer.deserializeClass(classId)

-    public fun withNameResolver(nameResolver: NameResolver): DeserializationContext {
-        return DeserializationContext(components, classDeserializer, nameResolver)
-    }
-}
-
-fun DeserializationGlobalContext.deserializeClass(classId: ClassId): ClassDescriptor? {
-    return classDeserializer.deserializeClass(classId)
+    public fun createContext(nameResolver: NameResolver): DeserializationContext = DeserializationContext(this, nameResolver)
 }


 public open class DeserializationContext(
-        components: DeserializationComponents,
-        classDeserializer: ClassDeserializer,
+        public val components: DeserializationComponents,
        public val nameResolver: NameResolver
-) : DeserializationGlobalContext(components, classDeserializer) {
+) {
    fun withTypes(containingDeclaration: DeclarationDescriptor, parent: TypeDeserializer? = null): DeserializationContextWithTypes {
        val typeDeserializer = TypeDeserializer(this, parent, "Deserializer for ${containingDeclaration.getName()}")
-        return DeserializationContextWithTypes(components, classDeserializer, nameResolver, containingDeclaration, typeDeserializer)
+        return DeserializationContextWithTypes(components, nameResolver, containingDeclaration, typeDeserializer)
    }
 }


 class DeserializationContextWithTypes(
        components: DeserializationComponents,
-        classDeserializer: ClassDeserializer,
        nameResolver: NameResolver,
        val containingDeclaration: DeclarationDescriptor,
        val typeDeserializer: TypeDeserializer
-) : DeserializationContext(components, classDeserializer, nameResolver) {
+) : DeserializationContext(components, nameResolver) {
    val memberDeserializer: MemberDeserializer = MemberDeserializer(this)

    fun childContext(descriptor: DeclarationDescriptor, typeParameterProtos: List<TypeParameter>): DeserializationContextWithTypes {
@@ -75,7 +75,7 @@ public class DeserializedClassDescriptor(
            return fragments.single()
        }
        else {
-            return context.deserializeClass(classId.getOuterClassId()) ?: ErrorUtils.getErrorModule()
+            return components.deserializeClass(classId.getOuterClassId()) ?: ErrorUtils.getErrorModule()
        }
    }

@@ -135,7 +135,7 @@ public class DeserializedClassDescriptor(
            return DeserializedClassDescriptor(context, classObjectProto.getData())
        }

-        return context.deserializeClass(classId.createNestedClassId(getClassObjectName(getName())))
+        return components.deserializeClass(classId.createNestedClassId(getClassObjectName(getName())))
    }

    override fun getClassObjectDescriptor(): ClassDescriptor? = classObjectDescriptor()
@@ -254,8 +254,8 @@ public class DeserializedClassDescriptor(

        val findNestedClass = components.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
            name ->
-            if (nestedClassNames.contains(name)) {
-                context.deserializeClass(classId.createNestedClassId(name))
+            if (name in nestedClassNames) {
+                components.deserializeClass(classId.createNestedClassId(name))
            }
            else null
        }
@@ -28,11 +28,17 @@ import org.jetbrains.jet.utils.addIfNotNull
 import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter


-public fun DeserializedPackageMemberScope(packageDescriptor: PackageFragmentDescriptor,
-                                          packageData: PackageData,
-                                          context: DeserializationGlobalContext,
-                                          classNames: () -> Collection<Name>): DeserializedPackageMemberScope
-        = DeserializedPackageMemberScope(packageDescriptor, packageData.getPackageProto(), context.withNameResolver(packageData.getNameResolver()), classNames)
+public fun DeserializedPackageMemberScope(
+        packageDescriptor: PackageFragmentDescriptor,
+        packageData: PackageData,
+        components: DeserializationComponents,
+        classNames: () -> Collection<Name>
+): DeserializedPackageMemberScope = DeserializedPackageMemberScope(
+        packageDescriptor,
+        packageData.getPackageProto(),
+        components.createContext(packageData.getNameResolver()),
+        classNames
+)

 public open class DeserializedPackageMemberScope(
        packageDescriptor: PackageFragmentDescriptor,
@@ -47,7 +53,7 @@ public open class DeserializedPackageMemberScope(
    override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean)
            = computeDescriptors(kindFilter, nameFilter)

-    override fun getClassDescriptor(name: Name) = context.deserializeClass(ClassId(packageFqName, name))
+    override fun getClassDescriptor(name: Name) = context.components.deserializeClass(ClassId(packageFqName, name))

    override fun addClassDescriptors(result: MutableCollection<DeclarationDescriptor>, nameFilter: (Name) -> Boolean) {
        for (className in classNames()) {
@@ -38,7 +38,6 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
 import org.jetbrains.jet.descriptors.serialization.ClassData
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.jet.plugin.decompiler.isKotlinWithCompatibleAbiVersion
-import org.jetbrains.jet.descriptors.serialization.context.deserializeClass

 public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDecompiler {
    val kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(classFile)
@@ -54,7 +53,7 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di

    private fun createDummyModule(name: String) = ModuleDescriptorImpl(Name.special("<$name>"), listOf(), PlatformToKotlinClassMap.EMPTY)

-    override fun resolveTopLevelClass(classId: ClassId) = deserializationContext.deserializeClass(classId)
+    override fun resolveTopLevelClass(classId: ClassId) = deserializationComponents.deserializeClass(classId)

    override fun resolveDeclarationsInPackage(packageFqName: FqName): Collection<DeclarationDescriptor> {
        assert(packageFqName == directoryPackageFqName, "Was called for $packageFqName but only $directoryPackageFqName is expected.")
@@ -67,7 +66,7 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
        val membersScope = DeserializedPackageMemberScope(
                createDummyPackageFragment(packageFqName),
                JavaProtoBufUtil.readPackageDataFrom(annotationData),
-                deserializationContext
+                deserializationComponents
        ) { listOf() }
        return membersScope.getDescriptors()
    }
@@ -147,10 +146,10 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
        moduleContainingMissingDependencies.seal()
    }

-    val deserializationContext = DeserializationComponents(
+    private val deserializationComponents = DeserializationComponents(
            storageManager, moduleDescriptor, classDataFinder, annotationLoader, constantLoader, packageFragmentProvider,
            JavaFlexibleTypeCapabilitiesDeserializer
-    ).createContext()
+    )

    private fun createDummyPackageFragment(fqName: FqName): MutablePackageFragmentDescriptor {
        return MutablePackageFragmentDescriptor(moduleDescriptor, fqName)