Refactor CompilerConfiguration: keys -> Content roots

Represent classpath roots and java source roots as separate entities
2015-03-31 20:13:59 +03:00
parent 4e283fd62f
commit cb7617b3ca
29 changed files with 265 additions and 143 deletions
@@ -29,7 +29,6 @@ import kotlin.Function1;
 import kotlin.Unit;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.utils.serializer.KotlinJavaScriptSerializer;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.cli.common.CLICompiler;
@@ -42,11 +41,10 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation;
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.CompilerJarLocator;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
+import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.Services;
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS;
@@ -59,6 +57,7 @@ import org.jetbrains.kotlin.js.facade.MainCallParameters;
 import org.jetbrains.kotlin.js.facade.TranslationResult;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.utils.PathUtil;
+import org.jetbrains.kotlin.utils.serializer.KotlinJavaScriptSerializer;

 import java.io.File;
 import java.util.List;
@@ -66,6 +65,7 @@ import java.util.List;
 import static org.jetbrains.kotlin.cli.common.ExitCode.COMPILATION_ERROR;
 import static org.jetbrains.kotlin.cli.common.ExitCode.OK;
 import static org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation.NO_LOCATION;
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoots;

 public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {

@@ -101,7 +101,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
            configuration.put(JVMConfigurationKeys.COMPILER_JAR_LOCATOR, locator);
        }

-        configuration.addAll(CommonConfigurationKeys.SOURCE_ROOTS_KEY, arguments.freeArgs);
+        addKotlinSourceRoots(configuration, arguments.freeArgs);
        KotlinCoreEnvironment environmentForJS =
                KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES);

@@ -27,10 +27,12 @@ import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments;
 import org.jetbrains.kotlin.cli.common.messages.*;
 import org.jetbrains.kotlin.cli.common.modules.ModuleScriptData;
 import org.jetbrains.kotlin.cli.jvm.compiler.*;
+import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.repl.ReplFromTerminal;
 import org.jetbrains.kotlin.codegen.CompilationException;
-import org.jetbrains.kotlin.compiler.plugin.*;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
+import org.jetbrains.kotlin.compiler.plugin.CliOptionProcessingException;
+import org.jetbrains.kotlin.compiler.plugin.PluginCliOptionProcessingException;
+import org.jetbrains.kotlin.compiler.plugin.PluginPackage;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.Services;
 import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCacheProvider;
@@ -45,6 +47,8 @@ import java.util.List;

 import static com.google.common.base.Predicates.in;
 import static org.jetbrains.kotlin.cli.common.ExitCode.*;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.*;
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;

@SuppressWarnings("UseOfSystemOutOrSystemErr")
 public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments> {
@@ -83,7 +87,7 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments> {

        try {
            if (!arguments.noJdk) {
-                configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots());
+                addJvmClasspathRoots(configuration, PathUtil.getJdkClassesRoots());
            }
        }
        catch (Throwable t) {
@@ -114,21 +118,20 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments> {
                                        CompilerMessageLocation.NO_LOCATION);
                return COMPILATION_ERROR;
            }
-            configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, arguments.freeArgs.get(0));
+            addKotlinSourceRoot(configuration, arguments.freeArgs.get(0));
        }
        else if (arguments.module == null) {
-            configuration.addAll(CommonConfigurationKeys.SOURCE_ROOTS_KEY, arguments.freeArgs);
-
-            // Adding all directory sources to classpath to resolve Java symbols from Kotlin
-            for (String source : arguments.freeArgs) {
-                File file = new File(source);
+            for (String arg : arguments.freeArgs) {
+                addKotlinSourceRoot(configuration, arg);
+                File file = new File(arg);
                if (file.isDirectory()) {
-                    configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, file);
+                    addJavaSourceRoot(configuration, file);
                }
            }
        }

-        configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, getClasspath(paths, arguments));
+        addJvmClasspathRoots(configuration, getClasspath(paths, arguments));
+
        configuration.addAll(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY, getAnnotationsPath(paths, arguments));

        if (arguments.module == null && arguments.freeArgs.isEmpty() && !arguments.version) {
@@ -42,11 +42,10 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil;
 import org.jetbrains.kotlin.cli.common.modules.ModuleScriptData;
 import org.jetbrains.kotlin.cli.common.modules.ModuleXmlParser;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
+import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.codegen.ClassFileFactory;
 import org.jetbrains.kotlin.codegen.GeneratedClassLoader;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.idea.JetFileType;
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
@@ -69,6 +68,9 @@ import java.util.jar.*;

 import static org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation.NO_LOCATION;
 import static org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.ERROR;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoots;
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;

 public class CompileEnvironmentUtil {

@@ -95,14 +97,15 @@ public class CompileEnvironmentUtil {
        CompilerConfiguration configuration = new CompilerConfiguration();
        File runtimePath = paths.getRuntimePath();
        if (runtimePath.exists()) {
-            configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, runtimePath);
+            addJvmClasspathRoot(configuration, runtimePath);
        }
-        configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots());
+        addJvmClasspathRoots(configuration, PathUtil.getJdkClassesRoots());
+
        File jdkAnnotationsPath = paths.getJdkAnnotationsPath();
        if (jdkAnnotationsPath.exists()) {
            configuration.add(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY, jdkAnnotationsPath);
        }
-        configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, moduleScriptFile);
+        addKotlinSourceRoot(configuration, moduleScriptFile);
        configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector);

        List<Module> modules;
@@ -37,6 +37,7 @@ import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.io.FileUtil
+import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.FileContextProvider
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.PsiManager
@@ -58,11 +59,13 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.ERROR
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.WARNING
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys
+import org.jetbrains.kotlin.cli.jvm.config.*
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.ContentRoot
+import org.jetbrains.kotlin.config.KotlinSourceRoot
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
 import org.jetbrains.kotlin.idea.JetFileType
 import org.jetbrains.kotlin.load.kotlin.KotlinBinaryClassCache
@@ -110,9 +113,8 @@ public class KotlinCoreEnvironment private(
        registerProjectServicesForCLI(projectEnvironment)
        registerProjectServices(projectEnvironment)

-        for (path in configuration.getList(JVMConfigurationKeys.CLASSPATH_KEY)) {
-            addToClasspath(path)
-        }
+        fillClasspath(configuration)
+
        for (path in configuration.getList(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY)) {
            addExternalAnnotationsRoot(path)
        }
@@ -155,33 +157,55 @@ public class KotlinCoreEnvironment private(
        annotationsManager.addExternalAnnotationsRoot(PathUtil.jarFileOrDirectoryToVirtualFile(path))
    }

-    private fun addToClasspath(path: File) {
-        if (path.isFile()) {
-            val jarFile = applicationEnvironment.getJarFileSystem().findFileByPath("${path}!/")
-            if (jarFile == null) {
-                report(WARNING, "Classpath entry points to a file that is not a JAR archive: $path")
-                return
-            }
-            projectEnvironment.addJarToClassPath(path)
-            classPath.add(jarFile)
+    private fun fillClasspath(configuration: CompilerConfiguration) {
+        for (root in configuration.getList(CommonConfigurationKeys.CONTENT_ROOTS)) {
+            val javaRoot = root as? JvmContentRoot ?: continue
+            val virtualFile = contentRootToVirtualFile(javaRoot) ?: continue
+
+            projectEnvironment.addSourcesToClasspath(virtualFile)
+            classPath.add(virtualFile)
        }
-        else {
-            val root = applicationEnvironment.getLocalFileSystem().findFileByPath(path.getAbsolutePath())
-            if (root == null) {
-                report(WARNING, "Classpath entry points to a non-existent location: $path")
-                return
+    }
+
+    private fun contentRootToVirtualFile(root: JvmContentRoot): VirtualFile? {
+        when (root) {
+            is JvmClasspathRoot -> {
+                return if (root.file.isFile()) findJarRoot(root) else findLocalDirectory(root)
            }
-            projectEnvironment.addSourcesToClasspath(root)
-            classPath.add(root)
+            is JavaSourceRoot -> {
+                return if (root.file.isDirectory()) findLocalDirectory(root) else null
+            }
+            else -> throw IllegalStateException("Unexpected root: $root")
        }
    }

+    private fun findLocalDirectory(root: JvmContentRoot): VirtualFile? {
+        val path = root.file
+        val localFile = applicationEnvironment.getLocalFileSystem().findFileByPath(path.getAbsolutePath())
+        if (localFile == null) {
+            report(WARNING, "Classpath entry points to a non-existent location: $path")
+            return null
+        }
+        return localFile
+    }
+
+    private fun findJarRoot(root: JvmClasspathRoot): VirtualFile? {
+        val path = root.file
+        val jarFile = applicationEnvironment.getJarFileSystem().findFileByPath("${path}!/")
+        if (jarFile == null) {
+            report(WARNING, "Classpath entry points to a file that is not a JAR archive: $path")
+            return null
+        }
+        return jarFile
+    }
+
    private fun getSourceRootsCheckingForDuplicates(): Collection<String> {
        val uniqueSourceRoots = Sets.newLinkedHashSet<String>()

-        for (sourceRoot in configuration.getList(CommonConfigurationKeys.SOURCE_ROOTS_KEY)) {
-            if (!uniqueSourceRoots.add(sourceRoot)) {
-                report(WARNING, "Duplicate source root: " + sourceRoot)
+        configuration.getList(CommonConfigurationKeys.CONTENT_ROOTS).filterIsInstance<KotlinSourceRoot>().forEach { sourceRoot ->
+            val path = sourceRoot.path
+            if (!uniqueSourceRoots.add(path)) {
+                report(WARNING, "Duplicate source root: $path")
            }
        }

@@ -36,11 +36,10 @@ import org.jetbrains.kotlin.cli.common.CompilerPluginContext;
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
+import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.codegen.*;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.Progress;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
@@ -63,7 +62,14 @@ import org.jetbrains.kotlin.utils.KotlinPaths;
 import java.io.File;
 import java.net.URL;
 import java.net.URLClassLoader;
-import java.util.*;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.getJvmClasspathRoots;
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoots;

 public class KotlinToJVMBytecodeCompiler {

@@ -165,10 +171,10 @@ public class KotlinToJVMBytecodeCompiler {
        CompilerConfiguration configuration = base.copy();

        for (Module module : chunk) {
-            configuration.addAll(CommonConfigurationKeys.SOURCE_ROOTS_KEY, getAbsolutePaths(directory, module));
+            addKotlinSourceRoots(configuration, getAbsolutePaths(directory, module));

            for (String classpathRoot : module.getClasspathRoots()) {
-                configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, new File(classpathRoot));
+                addJvmClasspathRoot(configuration, new File(classpathRoot));
            }

            for (String annotationsRoot : module.getAnnotationsRoots()) {
@@ -261,7 +267,7 @@ public class KotlinToJVMBytecodeCompiler {
        GeneratedClassLoader classLoader;
        try {
            List<URL> classPaths = Lists.newArrayList(paths.getRuntimePath().toURI().toURL());
-            for (File file : configuration.get(JVMConfigurationKeys.CLASSPATH_KEY, Collections.<File>emptyList())) {
+            for (File file : getJvmClasspathRoots(configuration)) {
                classPaths.add(file.toURI().toURL());
            }
            classLoader = new GeneratedClassLoader(state.getFactory(),
@@ -14,7 +14,7 @@
 * limitations under the License.
 */

-package org.jetbrains.kotlin.cli.jvm;
+package org.jetbrains.kotlin.cli.jvm.config;

 import org.jetbrains.kotlin.cli.jvm.compiler.CompilerJarLocator;
 import org.jetbrains.kotlin.config.CompilerConfigurationKey;
@@ -28,7 +28,6 @@ public class JVMConfigurationKeys {
    private JVMConfigurationKeys() {
    }

-    public static final CompilerConfigurationKey<List<File>> CLASSPATH_KEY = CompilerConfigurationKey.create("classpath");
    public static final CompilerConfigurationKey<List<File>> ANNOTATIONS_PATH_KEY = CompilerConfigurationKey.create("annotations path");

    public static final CompilerConfigurationKey<List<AnalyzerScriptParameter>> SCRIPT_PARAMETERS =
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.config
+
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.ContentRoot
+import java.io.File
+
+public data class JvmClasspathRoot(public override val file: File): JvmContentRoot
+
+public data class JavaSourceRoot(public override val file: File): JvmContentRoot
+
+public trait JvmContentRoot : ContentRoot {
+    public val file: File
+}
+
+public fun CompilerConfiguration.addJvmClasspathRoot(file: File) {
+    add(CommonConfigurationKeys.CONTENT_ROOTS, JvmClasspathRoot(file))
+}
+
+public fun CompilerConfiguration.addJvmClasspathRoots(files: List<File>): Unit = files.forEach { addJvmClasspathRoot(it) }
+
+public val CompilerConfiguration.jvmClasspathRoots: List<File>
+    get() {
+        return get(CommonConfigurationKeys.CONTENT_ROOTS)?.filterIsInstance<JvmClasspathRoot>()?.map { it.file } ?: emptyList()
+    }
+
+public fun CompilerConfiguration.addJavaSourceRoot(file: File) {
+    add(CommonConfigurationKeys.CONTENT_ROOTS, JavaSourceRoot(file))
+}
+
+public fun CompilerConfiguration.addJavaSourceRoots(files: List<File>): Unit = files.forEach { addJavaSourceRoot(it) }
@@ -35,7 +35,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollectorToString;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
@@ -80,6 +79,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.getJvmClasspathRoots;
 import static org.jetbrains.kotlin.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.registerClassNameForScript;
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration;
@@ -154,7 +154,7 @@ public class ReplInterpreter {
        module.seal();

        List<URL> classpath = Lists.newArrayList();
-        for (File file : configuration.getList(JVMConfigurationKeys.CLASSPATH_KEY)) {
+        for (File file : getJvmClasspathRoots(configuration)) {
            try {
                classpath.add(file.toURI().toURL());
            }