Merge DeserializationGlobalContext with DeserializationComponents

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TopDownAnalyzerFacadeForJVM.java

@@ -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()
                             )
                     );

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt

@@ -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> {

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializationGlobalContextForJava.kt

@@ -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
         )
-)
+}

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java

@@ -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() {

core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.kt

@@ -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() }
         )
 

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

@@ -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) {
+public class ClassDeserializer(private val 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()
-
     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
+            // TODO: use outerClassContext
-            DeserializedClassDescriptor(context.withNameResolver(classData.getNameResolver()), classData.getClassProto())
+            DeserializedClassDescriptor(components.createContext(classData.getNameResolver()), classData.getClassProto())
         }
         else {
             null

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

@@ -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 fun deserializeClass(classId: ClassId): ClassDescriptor? = classDeserializer.deserializeClass(classId)
-        public val components: DeserializationComponents,
-        public val classDeserializer: ClassDeserializer = ClassDeserializer(components)
-) {
-    {
-        classDeserializer.globalContext = this
-    }
 
-    public fun withNameResolver(nameResolver: NameResolver): DeserializationContext {
+    public fun createContext(nameResolver: NameResolver): DeserializationContext = DeserializationContext(this, nameResolver)
-        return DeserializationContext(components, classDeserializer, nameResolver)
-    }
-}
-
-fun DeserializationGlobalContext.deserializeClass(classId: ClassId): ClassDescriptor? {
-    return classDeserializer.deserializeClass(classId)
 }
 
 
 public open class DeserializationContext(
-        components: DeserializationComponents,
+        public val components: DeserializationComponents,
-        classDeserializer: ClassDeserializer,
         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 {

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

@@ -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)) {
+            if (name in nestedClassNames) {
-                context.deserializeClass(classId.createNestedClassId(name))
+                components.deserializeClass(classId.createNestedClassId(name))
             }
             else null
         }

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

@@ -28,11 +28,17 @@ import org.jetbrains.jet.utils.addIfNotNull
 import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 
-public fun DeserializedPackageMemberScope(packageDescriptor: PackageFragmentDescriptor,
+public fun DeserializedPackageMemberScope(
-                                          packageData: PackageData,
+        packageDescriptor: PackageFragmentDescriptor,
-                                          context: DeserializationGlobalContext,
+        packageData: PackageData,
-                                          classNames: () -> Collection<Name>): DeserializedPackageMemberScope
+        components: DeserializationComponents,
-        = DeserializedPackageMemberScope(packageDescriptor, packageData.getPackageProto(), context.withNameResolver(packageData.getNameResolver()), classNames)
+        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()) {

idea/idea-analysis/src/org/jetbrains/jet/plugin/decompiler/textBuilder/DeserializerForDecompiler.kt

@@ -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)