Allow the usage of virtual JVM content roots in kotlinc (#4645)

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

@@ -30,8 +30,8 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.*
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.MessageUtil
 import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
-import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
+import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRootBase
-import org.jetbrains.kotlin.cli.jvm.config.JvmContentRoot
+import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootBase
 import org.jetbrains.kotlin.cli.jvm.config.JvmModulePathRoot
 import org.jetbrains.kotlin.cli.jvm.index.JavaRoot
 import org.jetbrains.kotlin.cli.jvm.modules.CliJavaModuleFinder
@@ -51,7 +51,7 @@ class ClasspathRootsResolver(
     private val psiManager: PsiManager,
     private val messageCollector: MessageCollector?,
     private val additionalModules: List<String>,
-    private val contentRootToVirtualFile: (JvmContentRoot) -> VirtualFile?,
+    private val contentRootToVirtualFile: (JvmContentRootBase) -> VirtualFile?,
     private val javaModuleFinder: CliJavaModuleFinder,
     private val requireStdlibModule: Boolean,
     private val outputDirectory: VirtualFile?,
@@ -71,11 +71,11 @@ class ClasspathRootsResolver(
         val jvmModulePathRoots = mutableListOf<VirtualFile>()
 
         for (contentRoot in contentRoots) {
-            if (contentRoot !is JvmContentRoot) continue
+            if (contentRoot !is JvmContentRootBase) continue
             val root = contentRootToVirtualFile(contentRoot) ?: continue
             when (contentRoot) {
                 is JavaSourceRoot -> javaSourceRoots += RootWithPrefix(root, contentRoot.packagePrefix)
-                is JvmClasspathRoot -> jvmClasspathRoots += root
+                is JvmClasspathRootBase -> jvmClasspathRoots += root
                 is JvmModulePathRoot -> jvmModulePathRoots += root
                 else -> error("Unknown root type: $contentRoot")
             }

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

@@ -404,7 +404,7 @@ class KotlinCoreEnvironment private constructor(
         }.orEmpty()
     }
 
-    private fun contentRootToVirtualFile(root: JvmContentRoot): VirtualFile? =
+    private fun contentRootToVirtualFile(root: JvmContentRootBase): VirtualFile? =
         when (root) {
             is JvmClasspathRoot ->
                 if (root.file.isFile) findJarRoot(root.file) else findExistingRoot(root, "Classpath entry")
@@ -412,6 +412,7 @@ class KotlinCoreEnvironment private constructor(
                 if (root.file.isFile) findJarRoot(root.file) else findExistingRoot(root, "Java module root")
             is JavaSourceRoot ->
                 findExistingRoot(root, "Java source root")
+            is VirtualJvmClasspathRoot -> root.file
             else ->
                 throw IllegalStateException("Unexpected root: $root")
         }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JvmContentRoots.kt

@@ -16,20 +16,43 @@
 
 package org.jetbrains.kotlin.cli.jvm.config
 
+import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.config.ContentRoot
 import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import java.io.File
 
-interface JvmContentRoot : ContentRoot {
+interface JvmContentRootBase : ContentRoot
+
+interface JvmClasspathRootBase : JvmContentRootBase {
+    val isSdkRoot: Boolean
+}
+
+/**
+ * JVM content root based on a physical file.
+ */
+interface JvmContentRoot : JvmContentRootBase {
     val file: File
 }
 
-data class JvmClasspathRoot(override val file: File, val isSdkRoot: Boolean) : JvmContentRoot {
+/**
+ * JVM content root containing class files in a physical file system (for example a JAR file).
+ */
+data class JvmClasspathRoot(override val file: File, override val isSdkRoot: Boolean) : JvmContentRoot, JvmClasspathRootBase {
     constructor(file: File) : this(file, false)
 }
 
+/**
+ * JVM content root containing class files in a virutal file system.
+ */
+data class VirtualJvmClasspathRoot(val file: VirtualFile, override val isSdkRoot: Boolean) : JvmClasspathRootBase {
+    constructor(file: VirtualFile) : this(file, false)
+}
+
+/**
+ * JVM content root in a physical file system that contains source files.
+ */
 data class JavaSourceRoot(override val file: File, val packagePrefix: String?) : JvmContentRoot
 
 data class JvmModulePathRoot(override val file: File) : JvmContentRoot