Refactor JDR: use JavaResolverCache in LazyJavaPackageFragmentProvider directly

Remove LazyJavaClassResolverWithCache
This actually can affect behaviour because JavaResolverCache has slightly different logic (uses CLASS key in BindingContext as opposed to FQNAME_TO_CLASS_DESCRIPTOR)

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

@@ -25,7 +25,6 @@ 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.kotlin.VirtualFileFinder;
@@ -50,7 +49,6 @@ 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 VirtualFileFinder virtualFileFinder;
@@ -73,13 +71,12 @@ 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.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.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, lazyJavaClassResolverWithCache, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, getJavaDescriptorResolver());
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, getJavaDescriptorResolver());
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(storageManager);
 

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

@@ -34,7 +34,6 @@ 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;
@@ -86,7 +85,6 @@ 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;
@@ -138,7 +136,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         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());
@@ -162,7 +159,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         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.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache, getJavaDescriptorResolver());
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor());
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(storageManager);
 

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

@@ -17,15 +17,13 @@ public class LazyJavaPackageFragmentProvider(
         private val _module: ModuleDescriptor
 ) : JavaPackageFragmentProvider {
 
-    private val outerClassResolver = outerContext.javaClassResolver
-
     private val c = LazyJavaResolverContext(
             this,
+            FragmentClassResolver(),
             outerContext.storageManager,
             outerContext.finder,
             outerContext.kotlinClassFinder,
             outerContext.deserializedDescriptorResolver,
-            FragmentClassResolver(),
             outerContext.externalAnnotationResolver,
             outerContext.externalSignatureResolver,
             outerContext.errorReporter,
@@ -84,16 +82,16 @@ public class LazyJavaPackageFragmentProvider(
             val outer = javaClass.getOuterClass()
             val scope = if (outer != null) {
                 val outerClass = resolveClass(outer)
-                if (outerClass == null) return outerClassResolver.resolveClass(javaClass)
+                if (outerClass == null) return c.javaResolverCache.getClass(javaClass)
                 outerClass.getUnsubstitutedInnerClassesScope()
             }
             else {
                 val outerPackage = getPackageFragment(fqName!!.parent())
-                if (outerPackage == null) return outerClassResolver.resolveClass(javaClass)
+                if (outerPackage == null) return c.javaResolverCache.getClass(javaClass)
                 outerPackage.getMemberScope()
             }
             return scope.getClassifier(javaClass.getName()) as? ClassDescriptor
-                        ?: outerClassResolver.resolveClass(javaClass)
+                        ?: c.javaResolverCache.getClass(javaClass)
         }
 
         override fun resolveClassByFqName(fqName: FqName): ClassDescriptor? {
@@ -102,7 +100,7 @@ public 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 = outerClassResolver.resolveClassByFqName(fqName)
+            val classFromSources = c.javaResolverCache.getClassResolvedFromSource(fqName)
             if (classFromSources != null) return classFromSources
 
             val (jClass, kClass) = c.findClassInJava(fqName)

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

@@ -38,7 +38,6 @@ open class GlobalJavaResolverContext(
         val finder: JavaClassFinder,
         val kotlinClassFinder: KotlinClassFinder,
         val deserializedDescriptorResolver: DeserializedDescriptorResolver,
-        val javaClassResolver: LazyJavaClassResolver,
         val externalAnnotationResolver: ExternalAnnotationResolver,
         val externalSignatureResolver: ExternalSignatureResolver,
         val errorReporter: ErrorReporter,
@@ -49,11 +48,11 @@ open class GlobalJavaResolverContext(
 
 open class LazyJavaResolverContext(
         val packageFragmentProvider: LazyJavaPackageFragmentProvider,
+        val javaClassResolver: LazyJavaClassResolver,
         storageManager: StorageManager,
         finder: JavaClassFinder,
         kotlinClassFinder: KotlinClassFinder,
         deserializedDescriptorResolver: DeserializedDescriptorResolver,
-        javaClassResolver: LazyJavaClassResolver,
         externalAnnotationResolver: ExternalAnnotationResolver,
         externalSignatureResolver: ExternalSignatureResolver,
         errorReporter: ErrorReporter,
@@ -61,7 +60,6 @@ open class LazyJavaResolverContext(
         javaResolverCache: JavaResolverCache,
         javaDescriptorResolver: JavaDescriptorResolver
 ) : GlobalJavaResolverContext(storageManager, finder, kotlinClassFinder, deserializedDescriptorResolver,
-                              javaClassResolver,
                               externalAnnotationResolver, externalSignatureResolver,
                               errorReporter, methodSignatureChecker, javaResolverCache,
                               javaDescriptorResolver)
@@ -70,11 +68,11 @@ fun LazyJavaResolverContext.withTypes(
         typeParameterResolver: TypeParameterResolver = TypeParameterResolver.EMPTY
 )  =  LazyJavaResolverContextWithTypes(
         packageFragmentProvider,
+        javaClassResolver,
         storageManager,
         finder,
         kotlinClassFinder,
         deserializedDescriptorResolver,
-        javaClassResolver,
         externalAnnotationResolver,
         externalSignatureResolver,
         errorReporter,
@@ -86,11 +84,11 @@ fun LazyJavaResolverContext.withTypes(
 
 class LazyJavaResolverContextWithTypes(
         packageFragmentProvider: LazyJavaPackageFragmentProvider,
+        javaClassResolver: LazyJavaClassResolver,
         storageManager: StorageManager,
         finder: JavaClassFinder,
         kotlinClassFinder: KotlinClassFinder,
         deserializedDescriptorResolver: DeserializedDescriptorResolver,
-        javaClassResolver: LazyJavaClassResolver,
         externalAnnotationResolver: ExternalAnnotationResolver,
         externalSignatureResolver: ExternalSignatureResolver,
         errorReporter: ErrorReporter,
@@ -99,7 +97,8 @@ class LazyJavaResolverContextWithTypes(
         javaDescriptorResolver: JavaDescriptorResolver,
         val typeResolver: LazyJavaTypeResolver,
         val typeParameterResolver: TypeParameterResolver
-) : LazyJavaResolverContext(packageFragmentProvider, storageManager, finder, kotlinClassFinder, deserializedDescriptorResolver, javaClassResolver,
+) : LazyJavaResolverContext(packageFragmentProvider, javaClassResolver, storageManager, finder,
+                            kotlinClassFinder, deserializedDescriptorResolver,
                             externalAnnotationResolver, externalSignatureResolver,
                             errorReporter, methodSignatureChecker, javaResolverCache,
                             javaDescriptorResolver)

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

@@ -26,27 +26,12 @@ import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader
 import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader.Kind
 import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaResolverCache
 
 trait LazyJavaClassResolver {
     fun resolveClass(javaClass: JavaClass): ClassDescriptor?
     fun resolveClassByFqName(fqName: FqName): ClassDescriptor?
 }
 
-class LazyJavaClassResolverWithCache(val javaResolverCache: JavaResolverCache) : LazyJavaClassResolver {
-    override fun resolveClass(javaClass: JavaClass): ClassDescriptor? {
-        val fqName = javaClass.getFqName()
-        if (fqName != null) {
-            return resolveClassByFqName(fqName)
-        }
-        return null
-    }
-
-    override fun resolveClassByFqName(fqName: FqName): ClassDescriptor? {
-        return javaResolverCache.getClassResolvedFromSource(fqName)
-    }
-}
-
 trait TypeParameterResolver {
     class object {
         object EMPTY : TypeParameterResolver {

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

@@ -36,7 +36,6 @@ 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;
@@ -134,7 +133,6 @@ public class GenerateInjectors {
         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);
@@ -161,7 +159,6 @@ 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, VirtualFileFinder.class, "virtualFileFinder",