Refactor JavaModule, support several roots in one module

In case of partial/incremental compilation, a module usually consists of
two roots, one of which is source and another is binary. Thus, it's
incorrect to divide modules into "binary" and "non-binary", and only
look for .class files in "binary" modules in
CliJavaModuleResolver.findJavaModule. The more correct way is to think
of a module as a collection of roots, and every root is either binary or
source

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/ClasspathRootsResolver.kt

@@ -109,7 +109,10 @@ class ClasspathRootsResolver(
 
         val psiFile = psiManager.findFile(moduleInfoFile) ?: return null
         val psiJavaModule = psiFile.children.singleOrNull { it is PsiJavaModule } as? PsiJavaModule ?: return null
-        return JavaModule.Explicit(JavaModuleInfo.create(psiJavaModule), root, moduleInfoFile, isBinary = false)
+
+        val roots = listOf(JavaModule.Root(root, isBinary = false))
+
+        return JavaModule.Explicit(JavaModuleInfo.create(psiJavaModule), roots, moduleInfoFile)
     }
 
     private fun modularBinaryRoot(root: VirtualFile, originalFile: File): JavaModule? {
@@ -124,14 +127,16 @@ class ClasspathRootsResolver(
 
         if (moduleInfoFile != null) {
             val moduleInfo = JavaModuleInfo.read(moduleInfoFile) ?: return null
-            return JavaModule.Explicit(moduleInfo, root, moduleInfoFile, isBinary = true)
+            return JavaModule.Explicit(moduleInfo, listOf(JavaModule.Root(root, isBinary = true)), moduleInfoFile)
         }
 
         // Only .jar files can be automatic modules
         if (isJar) {
+            val moduleRoot = listOf(JavaModule.Root(root, isBinary = true))
+
             val automaticModuleName = manifest?.getValue(AUTOMATIC_MODULE_NAME)
             if (automaticModuleName != null) {
-                return JavaModule.Automatic(automaticModuleName, root)
+                return JavaModule.Automatic(automaticModuleName, moduleRoot)
             }
 
             val moduleName = LightJavaModule.moduleName(originalFile.nameWithoutExtension)
@@ -139,7 +144,7 @@ class ClasspathRootsResolver(
                 report(ERROR, "Cannot infer automatic module name for the file", VfsUtilCore.getVirtualFileForJar(root) ?: root)
                 return null
             }
-            return JavaModule.Automatic(moduleName, root)
+            return JavaModule.Automatic(moduleName, moduleRoot)
         }
 
         return null
@@ -169,11 +174,15 @@ class ClasspathRootsResolver(
             if (existing == null) {
                 javaModuleFinder.addUserModule(module)
             }
-            else if (module.moduleRoot != existing.moduleRoot) {
-                val jar = VfsUtilCore.getVirtualFileForJar(module.moduleRoot) ?: module.moduleRoot
-                val existingPath = (VfsUtilCore.getVirtualFileForJar(existing.moduleRoot) ?: existing.moduleRoot).path
+            else if (module.moduleRoots != existing.moduleRoots) {
+                fun JavaModule.getRootFile() =
+                        moduleRoots.firstOrNull()?.file?.let { VfsUtilCore.getVirtualFileForJar(it) ?: it }
+
+                val thisFile = module.getRootFile()
+                val existingFile = existing.getRootFile()
+                val atExistingPath = if (existingFile == null) "" else " at: ${existingFile.path}"
                 report(STRONG_WARNING, "The root is ignored because a module with the same name '${module.name}' " +
-                                       "has been found earlier on the module path at: $existingPath", jar)
+                                       "has been found earlier on the module path$atExistingPath", thisFile)
             }
         }
 
@@ -212,10 +221,9 @@ class ClasspathRootsResolver(
                 report(ERROR, "Module $moduleName cannot be found in the module graph")
             }
             else {
-                result.add(JavaRoot(
-                        module.moduleRoot,
-                        if (module.isBinary) JavaRoot.RootType.BINARY else JavaRoot.RootType.SOURCE
-                ))
+                for ((root, isBinary) in module.moduleRoots) {
+                    result.add(JavaRoot(root, if (isBinary) JavaRoot.RootType.BINARY else JavaRoot.RootType.SOURCE))
+                }
             }
         }
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/modules/CliJavaModuleFinder.kt

@@ -42,6 +42,6 @@ class CliJavaModuleFinder(jrtFileSystemRoot: VirtualFile?) : JavaModuleFinder {
     private fun findSystemModule(moduleRoot: VirtualFile): JavaModule.Explicit? {
         val file = moduleRoot.findChild(PsiJavaModule.MODULE_INFO_CLS_FILE) ?: return null
         val moduleInfo = JavaModuleInfo.read(file) ?: return null
-        return JavaModule.Explicit(moduleInfo, moduleRoot, file, isBinary = true)
+        return JavaModule.Explicit(moduleInfo, listOf(JavaModule.Root(moduleRoot, isBinary = true)), file)
     }
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/modules/CliJavaModuleResolver.kt

@@ -46,13 +46,13 @@ class CliJavaModuleResolver(
 
         return when (file.fileType) {
             KotlinFileType.INSTANCE, JavaFileType.INSTANCE -> sourceModule
-            JavaClassFileType.INSTANCE -> userModules.firstOrNull { module -> module.isBinary && file in module }
+            JavaClassFileType.INSTANCE -> userModules.firstOrNull { module -> file in module }
             else -> null
         }
     }
 
     private operator fun JavaModule.contains(file: VirtualFile): Boolean =
-            VfsUtilCore.isAncestor(moduleRoot, file, false)
+            moduleRoots.any { (root, isBinary) -> isBinary && VfsUtilCore.isAncestor(root, file, false) }
 
     override fun checkAccessibility(
             fileFromOurModule: VirtualFile?, referencedFile: VirtualFile, referencedPackage: FqName?