Refactor JDR: create LazyJavaPackageFragmentProvider in injector

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

@@ -21,53 +21,20 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
-import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
-import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaClassResolverWithCache;
+import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
-import org.jetbrains.jet.lang.resolve.java.resolver.*;
-import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
-import org.jetbrains.jet.storage.StorageManager;
+
+import javax.inject.Inject;
 
 public class JavaDescriptorResolver implements DependencyClassByQualifiedNameResolver {
     public static final Name JAVA_ROOT = Name.special("<java_root>");
 
-    private final ModuleDescriptor module;
-    private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
+    private ModuleDescriptor module;
 
-    public JavaDescriptorResolver(
-            StorageManager storageManager,
-            JavaClassFinder javaClassFinder,
-            ExternalAnnotationResolver externalAnnotationResolver,
-            ExternalSignatureResolver externalSignatureResolver,
-            ErrorReporter errorReporter,
-            MethodSignatureChecker signatureChecker,
-            JavaResolverCache javaResolverCache,
-            DeserializedDescriptorResolver deserializedDescriptorResolver,
-            KotlinClassFinder kotlinClassFinder,
-            ModuleDescriptor module
-    ) {
-        this.module = module;
-        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(
-                new GlobalJavaResolverContext(
-                        storageManager,
-                        javaClassFinder,
-                        kotlinClassFinder,
-                        deserializedDescriptorResolver,
-                        new LazyJavaClassResolverWithCache(javaResolverCache),
-                        externalAnnotationResolver,
-                        externalSignatureResolver,
-                        errorReporter,
-                        signatureChecker,
-                        javaResolverCache,
-                        this
-                ),
-                module
-        );
-    }
+    private LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
 
     @NotNull
     public ModuleDescriptor getModule() {
@@ -75,18 +42,28 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     }
 
     @NotNull
-    public LazyJavaPackageFragmentProvider getPackageFragmentProvider() {
+    public PackageFragmentProvider getPackageFragmentProvider() {
         return lazyJavaPackageFragmentProvider;
     }
 
     @Nullable
     @Override
     public ClassDescriptor resolveClass(@NotNull FqName qualifiedName) {
-        return getPackageFragmentProvider().getClass(qualifiedName);
+        return lazyJavaPackageFragmentProvider.getClass(qualifiedName);
     }
 
     @Nullable
     public PackageFragmentDescriptor getPackageFragment(@NotNull FqName fqName) {
-        return getPackageFragmentProvider().getPackageFragment(fqName);
+        return lazyJavaPackageFragmentProvider.getPackageFragment(fqName);
+    }
+
+    @Inject
+    public void setModule(@NotNull ModuleDescriptor module) {
+        this.module = module;
+    }
+
+    @Inject
+    public void setLazyJavaPackageFragmentProvider(@NotNull LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider) {
+        this.lazyJavaPackageFragmentProvider = lazyJavaPackageFragmentProvider;
     }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaPackageFragmentProvider.kt

@@ -10,14 +10,15 @@ import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyPackageFragmentF
 import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider
 import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaPackageFragment
-import org.jetbrains.jet.lang.resolve.name.Name
-import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
 
-public open class LazyJavaPackageFragmentProvider(
-        private val outerContext: GlobalJavaResolverContext,
+public class LazyJavaPackageFragmentProvider(
+        outerContext: GlobalJavaResolverContext,
         private val _module: ModuleDescriptor
 ) : JavaPackageFragmentProvider {
+
+    private val outerClassResolver = outerContext.javaClassResolver
+
     private val c = LazyJavaResolverContext(
             this,
             outerContext.storageManager,
@@ -83,16 +84,16 @@ public open class LazyJavaPackageFragmentProvider(
             val outer = javaClass.getOuterClass()
             val scope = if (outer != null) {
                 val outerClass = resolveClass(outer)
-                if (outerClass == null) return outerContext.javaClassResolver.resolveClass(javaClass)
+                if (outerClass == null) return outerClassResolver.resolveClass(javaClass)
                 outerClass.getUnsubstitutedInnerClassesScope()
             }
             else {
                 val outerPackage = getPackageFragment(fqName!!.parent())
-                if (outerPackage == null) return outerContext.javaClassResolver.resolveClass(javaClass)
+                if (outerPackage == null) return outerClassResolver.resolveClass(javaClass)
                 outerPackage.getMemberScope()
             }
             return scope.getClassifier(javaClass.getName()) as? ClassDescriptor
-                        ?: outerContext.javaClassResolver.resolveClass(javaClass)
+                        ?: outerClassResolver.resolveClass(javaClass)
         }
 
         override fun resolveClassByFqName(fqName: FqName): ClassDescriptor? {
@@ -101,7 +102,7 @@ public open class LazyJavaPackageFragmentProvider(
 
             // TODO Here we prefer sources (something outside JDR subsystem) to binaries, which should actually be driven by module dependencies separation
             // See DeserializedDescriptorResolver.javaDescriptorFinder
-            val classFromSources = outerContext.javaClassResolver.resolveClassByFqName(fqName)
+            val classFromSources = outerClassResolver.resolveClassByFqName(fqName)
             if (classFromSources != null) return classFromSources
 
             val (jClass, kClass) = c.findClassInJava(fqName)