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)

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 {