Refactor JDR: create LazyJavaPackageFragmentProvider in injector

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -25,11 +25,13 @@ import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureR
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaClassResolverWithCache;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
 import org.jetbrains.annotations.NotNull;
@@ -48,11 +50,13 @@ public class InjectorForJavaDescriptorResolver {
     private final TraceBasedJavaResolverCache traceBasedJavaResolverCache;
     private final TraceBasedErrorReporter traceBasedErrorReporter;
     private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
+    private final LazyJavaClassResolverWithCache lazyJavaClassResolverWithCache;
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
     private final JavaDescriptorResolver javaDescriptorResolver;
-    private final JavaPackageFragmentProvider javaPackageFragmentProvider;
     private final VirtualFileFinder virtualFileFinder;
     private final ModuleDescriptorImpl module;
+    private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
+    private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     
@@ -69,12 +73,14 @@ public class InjectorForJavaDescriptorResolver {
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
         this.traceBasedErrorReporter = new TraceBasedErrorReporter();
         this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
+        this.lazyJavaClassResolverWithCache = new LazyJavaClassResolverWithCache(traceBasedJavaResolverCache);
         this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
-        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
+        this.javaDescriptorResolver = new JavaDescriptorResolver();
         this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder.SERVICE.getInstance(project);
         this.module = org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule("<fake-jdr-module>");
-        this.javaDescriptorResolver = new JavaDescriptorResolver(storageManager, getJavaClassFinder(), psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, deserializedDescriptorResolver, virtualFileFinder, getModule());
+        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
-        this.javaPackageFragmentProvider = javaDescriptorResolver.getPackageFragmentProvider();
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, lazyJavaClassResolverWithCache, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, getJavaDescriptorResolver());
+        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(storageManager);
 
         this.javaClassFinder.setProject(project);
@@ -89,10 +95,13 @@ public class InjectorForJavaDescriptorResolver {
         psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
         psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
 
+        this.javaDescriptorResolver.setLazyJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
+        this.javaDescriptorResolver.setModule(module);
+
         deserializedDescriptorResolver.setAnnotationDeserializer(annotationDescriptorDeserializer);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
-        deserializedDescriptorResolver.setJavaPackageFragmentProvider(javaPackageFragmentProvider);
+        deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
         deserializedDescriptorResolver.setStorageManager(storageManager);
 
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -34,10 +34,10 @@ import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaClassResolverWithCache;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
@@ -57,6 +57,8 @@ import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver;
 import org.jetbrains.jet.lang.resolve.FunctionAnalyzerExtension;
 import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
 import org.jetbrains.annotations.NotNull;
@@ -84,10 +86,10 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final TraceBasedJavaResolverCache traceBasedJavaResolverCache;
     private final TraceBasedErrorReporter traceBasedErrorReporter;
+    private final LazyJavaClassResolverWithCache lazyJavaClassResolverWithCache;
     private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
-    private final JavaPackageFragmentProvider javaPackageFragmentProvider;
     private final VirtualFileFinder virtualFileFinder;
     private final DeclarationResolver declarationResolver;
     private final AnnotationResolver annotationResolver;
@@ -107,6 +109,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final DelegatedPropertyResolver delegatedPropertyResolver;
     private final FunctionAnalyzerExtension functionAnalyzerExtension;
     private final ScriptBodyResolver scriptBodyResolver;
+    private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
+    private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     
@@ -128,18 +132,17 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.topDownAnalysisParameters = topDownAnalysisParameters;
         this.bindingTrace = bindingTrace;
         this.moduleDescriptor = moduleDescriptor;
-        this.javaClassFinder = new JavaClassFinderImpl();
+        this.javaDescriptorResolver = new JavaDescriptorResolver();
-        this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
-        this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
-        this.traceBasedErrorReporter = new TraceBasedErrorReporter();
-        this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
-        this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
-        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
-        this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder.SERVICE.getInstance(project);
-        this.javaDescriptorResolver = new JavaDescriptorResolver(storageManager, javaClassFinder, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, deserializedDescriptorResolver, virtualFileFinder, getModuleDescriptor());
         this.javaToKotlinClassMap = org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap.getInstance();
+        this.javaClassFinder = new JavaClassFinderImpl();
+        this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
+        this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
+        this.traceBasedErrorReporter = new TraceBasedErrorReporter();
+        this.lazyJavaClassResolverWithCache = new LazyJavaClassResolverWithCache(traceBasedJavaResolverCache);
+        this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
+        this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
-        this.javaPackageFragmentProvider = javaDescriptorResolver.getPackageFragmentProvider();
+        this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder.SERVICE.getInstance(project);
         this.declarationResolver = new DeclarationResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -158,6 +161,9 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.delegatedPropertyResolver = new DelegatedPropertyResolver();
         this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
         this.scriptBodyResolver = new ScriptBodyResolver();
+        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, lazyJavaClassResolverWithCache, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, getJavaDescriptorResolver());
+        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor());
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(storageManager);
 
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
@@ -196,6 +202,9 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.descriptorResolver.setStorageManager(storageManager);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
+        this.javaDescriptorResolver.setLazyJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
+        this.javaDescriptorResolver.setModule(moduleDescriptor);
+
         javaClassFinder.setProject(project);
 
         traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
@@ -281,7 +290,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         deserializedDescriptorResolver.setAnnotationDeserializer(annotationDescriptorDeserializer);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
-        deserializedDescriptorResolver.setJavaPackageFragmentProvider(javaPackageFragmentProvider);
+        deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
         deserializedDescriptorResolver.setStorageManager(storageManager);
 
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);

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.descriptors.PackageFragmentProvider;
-import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaClassResolverWithCache;
 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 ModuleDescriptor module;
-    private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
 
-    public JavaDescriptorResolver(
+    private LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
-            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
-        );
-    }
 
     @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(
+public class LazyJavaPackageFragmentProvider(
-        private val outerContext: GlobalJavaResolverContext,
+        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)

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java

@@ -36,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaClassResolverWithCache;
 import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.java.resolver.*;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
@@ -127,15 +128,16 @@ public class GenerateInjectors {
         generator.implementInterface(InjectorForTopDownAnalyzer.class);
         generateInjectorForTopDownAnalyzerCommon(generator);
         generator.addPublicField(JavaDescriptorResolver.class);
-        generator.addField(false, JavaToKotlinClassMap.class, null, new GivenExpression("org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap.getInstance()"));
+        generator.addField(false, JavaToKotlinClassMap.class, null,
+                           new GivenExpression("org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap.getInstance()"));
         generator.addField(JavaClassFinderImpl.class);
         generator.addField(TraceBasedExternalSignatureResolver.class);
         generator.addField(TraceBasedJavaResolverCache.class);
         generator.addField(TraceBasedErrorReporter.class);
+        generator.addField(LazyJavaClassResolverWithCache.class);
         generator.addField(PsiBasedMethodSignatureChecker.class);
         generator.addField(PsiBasedExternalAnnotationResolver.class);
         generator.addField(MutablePackageFragmentProvider.class);
-        generator.addField(false, JavaPackageFragmentProvider.class, null, new GivenExpression("javaDescriptorResolver.getPackageFragmentProvider()"));
         generator.addField(false, VirtualFileFinder.class, "virtualFileFinder",
                            new GivenExpression(
                                    VirtualFileFinder.class.getName() + ".SERVICE.getInstance(project)"));
@@ -159,9 +161,9 @@ public class GenerateInjectors {
         generator.addField(TraceBasedJavaResolverCache.class);
         generator.addField(TraceBasedErrorReporter.class);
         generator.addField(PsiBasedMethodSignatureChecker.class);
+        generator.addField(LazyJavaClassResolverWithCache.class);
         generator.addField(PsiBasedExternalAnnotationResolver.class);
         generator.addPublicField(JavaDescriptorResolver.class);
-        generator.addField(false, JavaPackageFragmentProvider.class, null, new GivenExpression("javaDescriptorResolver.getPackageFragmentProvider()"));
         generator.addField(false, VirtualFileFinder.class, "virtualFileFinder",
                            new GivenExpression(VirtualFileFinder.class.getName() + ".SERVICE.getInstance(project)"));
         generator.addField(true, ModuleDescriptorImpl.class, "module",