Refactor Java resolver components

- Move components from LazyJavaResolverContext to JavaResolverComponents
- Drop LazyJavaClassResolver replacing it's usages with module resolver
(now enum entries from another module as annotation arguments are being resolved, see test)

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaPackageFragmentProvider.kt

@@ -16,26 +16,18 @@
 
 package org.jetbrains.kotlin.load.java.lazy
 
-import org.jetbrains.kotlin.builtins.ReflectionTypes
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaPackageFragment
-import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.storage.MemoizedFunctionToNullable
 import org.jetbrains.kotlin.utils.emptyOrSingletonList
 
 class LazyJavaPackageFragmentProvider(
-        components: JavaResolverComponents,
-        module: ModuleDescriptor,
-        reflectionTypes: ReflectionTypes
+        components: JavaResolverComponents
 ) : PackageFragmentProvider {
 
-    private val c =
-            LazyJavaResolverContext(components, this, FragmentClassResolver(), module, reflectionTypes, TypeParameterResolver.EMPTY)
+    private val c = LazyJavaResolverContext(components, TypeParameterResolver.EMPTY)
 
     private val packageFragments: MemoizedFunctionToNullable<FqName, LazyJavaPackageFragment> =
             c.storageManager.createMemoizedFunctionWithNullableValues {
@@ -53,24 +45,4 @@ class LazyJavaPackageFragmentProvider(
 
     override fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean) =
             getPackageFragment(fqName)?.getSubPackageFqNames().orEmpty()
-
-    fun getClass(javaClass: JavaClass): ClassDescriptor? = c.javaClassResolver.resolveClass(javaClass)
-
-    private inner class FragmentClassResolver : LazyJavaClassResolver {
-        override fun resolveClass(javaClass: JavaClass): ClassDescriptor? {
-            val fqName = javaClass.fqName
-            if (fqName != null && javaClass.isKotlinLightClass) {
-                return c.components.javaResolverCache.getClassResolvedFromSource(fqName)
-            }
-
-            javaClass.outerClass?.let { outerClass ->
-                val outerClassScope = resolveClass(outerClass)?.unsubstitutedInnerClassesScope
-                return outerClassScope?.getContributedClassifier(javaClass.name, NoLookupLocation.FROM_JAVA_LOADER) as? ClassDescriptor
-            }
-
-            if (fqName == null) return null
-
-            return getPackageFragment(fqName.parent())?.findClassifierByJavaClass(javaClass)
-        }
-    }
 }

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/context.kt

@@ -47,7 +47,9 @@ class JavaResolverComponents(
         val moduleClassResolver: ModuleClassResolver,
         val packageMapper: PackagePartProvider,
         val supertypeLoopChecker: SupertypeLoopChecker,
-        val lookupTracker: LookupTracker
+        val lookupTracker: LookupTracker,
+        val module: ModuleDescriptor,
+        val reflectionTypes: ReflectionTypes
 ) {
     fun replace(
             javaResolverCache: JavaResolverCache = this.javaResolverCache
@@ -55,30 +57,28 @@ class JavaResolverComponents(
             storageManager, finder, kotlinClassFinder, deserializedDescriptorResolver,
             externalAnnotationResolver, signaturePropagator, errorReporter, javaResolverCache,
             javaPropertyInitializerEvaluator, samConversionResolver, sourceElementFactory,
-            moduleClassResolver, packageMapper, supertypeLoopChecker, lookupTracker)
+            moduleClassResolver, packageMapper, supertypeLoopChecker, lookupTracker, module, reflectionTypes)
 }
 
 open class LazyJavaResolverContext(
         val components: JavaResolverComponents,
-        val packageFragmentProvider: LazyJavaPackageFragmentProvider,
-        val javaClassResolver: LazyJavaClassResolver,
-        val module: ModuleDescriptor,
-        val reflectionTypes: ReflectionTypes,
         val typeParameterResolver: TypeParameterResolver
 ) {
     val typeResolver = LazyJavaTypeResolver(this, typeParameterResolver)
 
     val storageManager: StorageManager
         get() = components.storageManager
+
+    val module: ModuleDescriptor get() = components.module
 }
 
 fun LazyJavaResolverContext.child(
         typeParameterResolver: TypeParameterResolver
-) = LazyJavaResolverContext(components, packageFragmentProvider, javaClassResolver, module, reflectionTypes, typeParameterResolver)
+) = LazyJavaResolverContext(components, typeParameterResolver)
 
 fun LazyJavaResolverContext.replaceComponents(
         components: JavaResolverComponents
-) = LazyJavaResolverContext(components, packageFragmentProvider, javaClassResolver, module, reflectionTypes, typeParameterResolver)
+) = LazyJavaResolverContext(components, typeParameterResolver)
 
 fun LazyJavaResolverContext.child(
         containingDeclaration: DeclarationDescriptor,

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt

@@ -118,8 +118,7 @@ class LazyJavaAnnotationDescriptor(
 
         val containingJavaClass = element.containingClass
 
-        //TODO: (module refactoring) moduleClassResolver should be used here
-        val enumClass = c.javaClassResolver.resolveClass(containingJavaClass) ?: return null
+        val enumClass = c.components.moduleClassResolver.resolveClass(containingJavaClass) ?: return null
 
         val classifier = enumClass.unsubstitutedInnerClassesScope.getContributedClassifier(element.name, NoLookupLocation.FROM_JAVA_LOADER)
         if (classifier !is ClassDescriptor) return null

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/resolvers.kt

@@ -16,20 +16,13 @@
 
 package org.jetbrains.kotlin.load.java.lazy
 
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaTypeParameterDescriptor
-import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter
 import org.jetbrains.kotlin.load.java.structure.JavaTypeParameterListOwner
 import org.jetbrains.kotlin.utils.mapToIndex
 
-//TODO: (module refactoring) usages of this interface should be replaced by ModuleClassResolver
-interface LazyJavaClassResolver {
-    fun resolveClass(javaClass: JavaClass): ClassDescriptor?
-}
-
 interface TypeParameterResolver {
     object EMPTY : TypeParameterResolver {
         override fun resolveTypeParameter(javaTypeParameter: JavaTypeParameter): TypeParameterDescriptor? = null

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt

@@ -133,7 +133,7 @@ class LazyJavaTypeResolver(
 
         private fun mapKotlinClass(fqName: FqName): ClassDescriptor? {
             if (attr.isForAnnotationParameter && fqName == JAVA_LANG_CLASS_FQ_NAME) {
-                return c.reflectionTypes.kClass
+                return c.components.reflectionTypes.kClass
             }
 
             val javaToKotlin = JavaToKotlinClassMap.INSTANCE

core/descriptor.loader.java/src/org/jetbrains/kotlin/resolve/jvm/JavaDescriptorResolver.kt

@@ -17,11 +17,28 @@
 package org.jetbrains.kotlin.resolve.jvm
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.load.java.components.JavaResolverCache
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 
-class JavaDescriptorResolver(val packageFragmentProvider: LazyJavaPackageFragmentProvider) {
+class JavaDescriptorResolver(
+        val packageFragmentProvider: LazyJavaPackageFragmentProvider,
+        private val javaResolverCache: JavaResolverCache
+) {
     fun resolveClass(javaClass: JavaClass): ClassDescriptor? {
-        return packageFragmentProvider.getClass(javaClass)
+        val fqName = javaClass.fqName
+        if (fqName != null && javaClass.isKotlinLightClass) {
+            return javaResolverCache.getClassResolvedFromSource(fqName)
+        }
+
+        javaClass.outerClass?.let { outerClass ->
+            val outerClassScope = resolveClass(outerClass)?.unsubstitutedInnerClassesScope
+            return outerClassScope?.getContributedClassifier(javaClass.name, NoLookupLocation.FROM_JAVA_LOADER) as? ClassDescriptor
+        }
+
+        if (fqName == null) return null
+
+        return packageFragmentProvider.getPackageFragments(fqName.parent()).firstOrNull()?.findClassifierByJavaClass(javaClass)
     }
 }