Rename: LazyJavaSubModule -> LazyJavaPackageFragmentProvider

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

@@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaClassResolver;
-import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaSubModule;
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.resolver.*;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
@@ -78,7 +78,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     private JavaPackageFragmentProvider packageFragmentProvider;
     private JavaClassFinder javaClassFinder;
     private ExternalAnnotationResolver externalAnnotationResolver;
-    private LazyJavaSubModule subModule;
+    private LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private ExternalSignatureResolver externalSignatureResolver;
     private ErrorReporter errorReporter;
     private MethodSignatureChecker signatureChecker;
@@ -143,9 +143,9 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     }
 
     @NotNull
-    private LazyJavaSubModule getSubModule() {
+    private LazyJavaPackageFragmentProvider getLazyJavaPackageFragmentProvider() {
-        if (subModule == null) {
+        if (lazyJavaPackageFragmentProvider == null) {
-            subModule = new LazyJavaSubModule(
+            lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(
                     new GlobalJavaResolverContext(
                             storageManager,
                             new JavaClassFinder() {
@@ -214,13 +214,13 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
                     module
             );
         }
-        return subModule;
+        return lazyJavaPackageFragmentProvider;
     }
 
     @Nullable
     public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
         if (LAZY) {
-            return getSubModule().getClass(qualifiedName);
+            return getLazyJavaPackageFragmentProvider().getClass(qualifiedName);
         }
         return classResolver.resolveClass(qualifiedName, searchRule);
     }

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

@@ -11,11 +11,9 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver
 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.descriptor.JavaPackageFragmentDescriptor
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver
 import org.jetbrains.jet.lang.resolve.name.Name
-import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
 
-public open class LazyJavaSubModule(
+public open class LazyJavaPackageFragmentProvider(
         private val outerContext: GlobalJavaResolverContext,
         private val _module: ModuleDescriptor
 ) : JavaPackageFragmentProvider {
@@ -23,7 +21,7 @@ public open class LazyJavaSubModule(
             this,
             outerContext.storageManager,
             outerContext.finder,
-            SubModuleClassResolver(),
+            FragmentClassResolver(),
             outerContext.externalAnnotationResolver,
             outerContext.externalSignatureResolver,
             outerContext.errorReporter,
@@ -59,7 +57,7 @@ public open class LazyJavaSubModule(
 
     fun getClass(fqName: FqName): ClassDescriptor? = c.javaClassResolver.resolveClassByFqName(fqName)
 
-    private inner class SubModuleClassResolver : LazyJavaClassResolver {
+    private inner class FragmentClassResolver : LazyJavaClassResolver {
         override fun resolveClass(javaClass: JavaClass): ClassDescriptor? {
             // TODO: there's no notion of module separation here. We must refuse to resolve classes from other modules
             val fqName = javaClass.getFqName()

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

@@ -41,7 +41,7 @@ open class GlobalJavaResolverContext(
 )
 
 open class LazyJavaResolverContext(
-        val subModule: LazyJavaSubModule,
+        val packageFragmentProvider: LazyJavaPackageFragmentProvider,
         storageManager: StorageManager,
         finder: JavaClassFinder,
         javaClassResolver: LazyJavaClassResolver,
@@ -59,7 +59,7 @@ open class LazyJavaResolverContext(
 fun LazyJavaResolverContext.withTypes(
         typeParameterResolver: TypeParameterResolver = TypeParameterResolver.EMPTY
 )  =  LazyJavaResolverContextWithTypes(
-        subModule,
+        packageFragmentProvider,
         storageManager,
         finder,
         javaClassResolver,
@@ -73,7 +73,7 @@ fun LazyJavaResolverContext.withTypes(
         typeParameterResolver)
 
 class LazyJavaResolverContextWithTypes(
-        subModule: LazyJavaSubModule,
+        packageFragmentProvider: LazyJavaPackageFragmentProvider,
         storageManager: StorageManager,
         finder: JavaClassFinder,
         javaClassResolver: LazyJavaClassResolver,
@@ -85,7 +85,7 @@ class LazyJavaResolverContextWithTypes(
         javaDescriptorResolver: JavaDescriptorResolver,
         val typeResolver: LazyJavaTypeResolver,
         val typeParameterResolver: TypeParameterResolver
-) : LazyJavaResolverContext(subModule, storageManager, finder, javaClassResolver,
+) : LazyJavaResolverContext(packageFragmentProvider, storageManager, finder, javaClassResolver,
                             externalAnnotationResolver, externalSignatureResolver,
                             errorReporter, methodSignatureChecker, javaResolverCache,
                             javaDescriptorResolver)

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

@@ -166,7 +166,7 @@ public class LazyJavaClassMemberScope(
             else null
         }
         else {
-            // TODO: this caching is a temporary workaround, should be replaced with properly caching the whole LazyJavaSubModule
+            // TODO: this caching is a temporary workaround, should be replaced with properly caching the whole LazyJavaPackageFragmentProvider
             val alreadyResolved = c.javaResolverCache.getClass(jNestedClass)
             if (alreadyResolved != null)
                 alreadyResolved

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

@@ -28,7 +28,7 @@ abstract class LazyJavaPackageFragment(
 
     override fun getJavaDescriptorResolver(): JavaDescriptorResolver = c.javaDescriptorResolver
 
-    override fun getProvider(): PackageFragmentProvider = c.subModule
+    override fun getProvider(): PackageFragmentProvider = c.packageFragmentProvider
 
     override fun <R, D> accept(visitor: DeclarationDescriptorVisitor<R, D>, data: D) = visitor.visitPackageFragmentDescriptor(this, data) as R