diff --git a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt b/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt index 8502bf230c4..5e28b5c9973 100644 --- a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt +++ b/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt @@ -24,11 +24,11 @@ import org.jetbrains.kotlin.analyzer.ModuleInfo import org.jetbrains.kotlin.builtins.BuiltInsSerializationUtil import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys import org.jetbrains.kotlin.cli.common.messages.MessageCollector -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys 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.addJvmClasspathRoots import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.config.addKotlinSourceRoots import org.jetbrains.kotlin.context.GlobalContext import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptor @@ -52,8 +52,8 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) { public fun serialize( destDir: File, - srcDirs: Collection, - extraClassPath: Collection, + srcDirs: List, + extraClassPath: List, onComplete: (totalSize: Int, totalFiles: Int) -> Unit ) { val rootDisposable = Disposer.newDisposable() @@ -73,16 +73,12 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) { if (dependOnOldBuiltIns) ModuleInfo.DependenciesOnBuiltins.LAST else ModuleInfo.DependenciesOnBuiltins.NONE } - private fun serialize(disposable: Disposable, destDir: File, srcDirs: Collection, extraClassPath: Collection) { + private fun serialize(disposable: Disposable, destDir: File, srcDirs: List, extraClassPath: List) { val configuration = CompilerConfiguration() configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE) - val sourceRoots = srcDirs map { it.path } - configuration.put(CommonConfigurationKeys.SOURCE_ROOTS_KEY, sourceRoots) - - for (path in extraClassPath) { - configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, path) - } + configuration.addKotlinSourceRoots(srcDirs.map { it.path }) + configuration.addJvmClasspathRoots(extraClassPath) val environment = KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java index 8f9c5e0474b..39cb4d635f0 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java @@ -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 { @@ -101,7 +101,7 @@ public class K2JSCompiler extends CLICompiler { 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); diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.java index a61ec597ca9..6c94f223397 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.java @@ -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 { @@ -83,7 +87,7 @@ public class K2JVMCompiler extends CLICompiler { 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 { 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) { diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CompileEnvironmentUtil.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CompileEnvironmentUtil.java index d6bff7167b4..8176d3580cf 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CompileEnvironmentUtil.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CompileEnvironmentUtil.java @@ -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 modules; diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt index b5f079b6c6a..975bcfcf555 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt @@ -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 { val uniqueSourceRoots = Sets.newLinkedHashSet() - 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().forEach { sourceRoot -> + val path = sourceRoot.path + if (!uniqueSourceRoots.add(path)) { + report(WARNING, "Duplicate source root: $path") } } diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index 511a9362609..55653c0a658 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -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 classPaths = Lists.newArrayList(paths.getRuntimePath().toURI().toURL()); - for (File file : configuration.get(JVMConfigurationKeys.CLASSPATH_KEY, Collections.emptyList())) { + for (File file : getJvmClasspathRoots(configuration)) { classPaths.add(file.toURI().toURL()); } classLoader = new GeneratedClassLoader(state.getFactory(), diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/JVMConfigurationKeys.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JVMConfigurationKeys.java similarity index 93% rename from compiler/cli/src/org/jetbrains/kotlin/cli/jvm/JVMConfigurationKeys.java rename to compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JVMConfigurationKeys.java index 30a4c1ca94d..22e59803368 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/JVMConfigurationKeys.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JVMConfigurationKeys.java @@ -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> CLASSPATH_KEY = CompilerConfigurationKey.create("classpath"); public static final CompilerConfigurationKey> ANNOTATIONS_PATH_KEY = CompilerConfigurationKey.create("annotations path"); public static final CompilerConfigurationKey> SCRIPT_PARAMETERS = diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JvmContentRoots.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JvmContentRoots.kt new file mode 100644 index 00000000000..30bad668fbd --- /dev/null +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JvmContentRoots.kt @@ -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): Unit = files.forEach { addJvmClasspathRoot(it) } + +public val CompilerConfiguration.jvmClasspathRoots: List + get() { + return get(CommonConfigurationKeys.CONTENT_ROOTS)?.filterIsInstance()?.map { it.file } ?: emptyList() + } + +public fun CompilerConfiguration.addJavaSourceRoot(file: File) { + add(CommonConfigurationKeys.CONTENT_ROOTS, JavaSourceRoot(file)) +} + +public fun CompilerConfiguration.addJavaSourceRoots(files: List): Unit = files.forEach { addJavaSourceRoot(it) } \ No newline at end of file diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java index ec371b745a8..b26078d3580 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java @@ -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 classpath = Lists.newArrayList(); - for (File file : configuration.getList(JVMConfigurationKeys.CLASSPATH_KEY)) { + for (File file : getJvmClasspathRoots(configuration)) { try { classpath.add(file.toURI().toURL()); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.java b/compiler/frontend/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.java index 31f45ff769f..5107d6a1410 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.java @@ -24,7 +24,8 @@ public class CommonConfigurationKeys { private CommonConfigurationKeys() { } - public static final CompilerConfigurationKey> SOURCE_ROOTS_KEY = CompilerConfigurationKey.create("source roots"); + // roots, including dependencies and own source + public static final CompilerConfigurationKey> CONTENT_ROOTS = CompilerConfigurationKey.create("content roots"); public static final CompilerConfigurationKey> SCRIPT_DEFINITIONS_KEY = CompilerConfigurationKey.create("script definitions"); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/config/ContentRoots.kt b/compiler/frontend/src/org/jetbrains/kotlin/config/ContentRoots.kt new file mode 100644 index 00000000000..b7b0d953601 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/config/ContentRoots.kt @@ -0,0 +1,28 @@ +/* + * 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.config + +public trait ContentRoot + +public data class KotlinSourceRoot(public val path: String): ContentRoot + +public fun CompilerConfiguration.addKotlinSourceRoot(source: String) { + add(CommonConfigurationKeys.CONTENT_ROOTS, KotlinSourceRoot(source)) +} + +public fun CompilerConfiguration.addKotlinSourceRoots(sources: List): Unit = sources.forEach { addKotlinSourceRoot(it) } + diff --git a/compiler/tests/org/jetbrains/kotlin/asJava/KotlinAsJavaTestBase.java b/compiler/tests/org/jetbrains/kotlin/asJava/KotlinAsJavaTestBase.java index c0f7f2c2fb6..ab156eb7646 100644 --- a/compiler/tests/org/jetbrains/kotlin/asJava/KotlinAsJavaTestBase.java +++ b/compiler/tests/org/jetbrains/kotlin/asJava/KotlinAsJavaTestBase.java @@ -19,13 +19,14 @@ package org.jetbrains.kotlin.asJava; import org.jetbrains.annotations.NotNull; 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.config.CompilerConfiguration; import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment; import java.io.File; import java.util.List; +import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot; + public abstract class KotlinAsJavaTestBase extends KotlinTestWithEnvironment { protected JavaElementFinder finder; @@ -34,7 +35,7 @@ public abstract class KotlinAsJavaTestBase extends KotlinTestWithEnvironment { CompilerConfiguration configuration = new CompilerConfiguration(); for (File root : getKotlinSourceRoots()) { - configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, root.getPath()); + addKotlinSourceRoot(configuration, root.getPath()); } extraConfiguration(configuration); diff --git a/compiler/tests/org/jetbrains/kotlin/asJava/KotlinLightClassStructureTest.java b/compiler/tests/org/jetbrains/kotlin/asJava/KotlinLightClassStructureTest.java index fd090f9b4f5..1a3eb855888 100644 --- a/compiler/tests/org/jetbrains/kotlin/asJava/KotlinLightClassStructureTest.java +++ b/compiler/tests/org/jetbrains/kotlin/asJava/KotlinLightClassStructureTest.java @@ -34,7 +34,7 @@ import java.util.List; import java.util.Set; import static org.jetbrains.kotlin.asJava.KotlinLightClassStructureTest.ClassProperty.*; -import static org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys.CLASSPATH_KEY; +import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot; @SuppressWarnings("JUnitTestClassNamingConvention") public abstract class KotlinLightClassStructureTest extends KotlinAsJavaTestBase { @@ -149,7 +149,7 @@ public abstract class KotlinLightClassStructureTest extends KotlinAsJavaTestBase @Override protected void extraConfiguration(@NotNull CompilerConfiguration configuration) { - configuration.add(CLASSPATH_KEY, ForTestCompileRuntime.runtimeJarForTests()); + addJvmClasspathRoot(configuration, ForTestCompileRuntime.runtimeJarForTests()); } } diff --git a/compiler/tests/org/jetbrains/kotlin/asJava/LightClassAnnotationsTest.java b/compiler/tests/org/jetbrains/kotlin/asJava/LightClassAnnotationsTest.java index fbd2c387de0..2cbed028533 100644 --- a/compiler/tests/org/jetbrains/kotlin/asJava/LightClassAnnotationsTest.java +++ b/compiler/tests/org/jetbrains/kotlin/asJava/LightClassAnnotationsTest.java @@ -21,7 +21,6 @@ import com.intellij.psi.PsiClass; import com.intellij.psi.PsiModifierList; import com.intellij.psi.search.GlobalSearchScope; import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys; import org.jetbrains.kotlin.config.CompilerConfiguration; import org.jetbrains.kotlin.test.JetTestUtils; @@ -29,6 +28,8 @@ import java.io.File; import java.util.Collections; import java.util.List; +import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot; + public class LightClassAnnotationsTest extends KotlinAsJavaTestBase { private final File testDir = new File("compiler/testData/asJava/annotations"); @@ -39,7 +40,7 @@ public class LightClassAnnotationsTest extends KotlinAsJavaTestBase { @Override protected void extraConfiguration(@NotNull CompilerConfiguration configuration) { - configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, JetTestUtils.getAnnotationsJar()); + addJvmClasspathRoot(configuration, JetTestUtils.getAnnotationsJar()); } public void testExtraAnnotations() throws Exception { diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithWithJava.java b/compiler/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithWithJava.java index 123b46374d1..b39c7b8878a 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithWithJava.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithWithJava.java @@ -23,7 +23,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; 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.config.CompilerConfiguration; import org.jetbrains.kotlin.test.ConfigurationKind; import org.jetbrains.kotlin.test.JetLiteFixture; @@ -39,6 +38,8 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot; + public abstract class KotlinMultiFileTestWithWithJava extends JetLiteFixture { protected class ModuleAndDependencies { final M module; @@ -73,7 +74,7 @@ public abstract class KotlinMultiFileTestWithWithJava extends JetLiteFixtu ); File kotlinSourceRoot = getKotlinSourceRoot(); if (kotlinSourceRoot != null) { - configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, kotlinSourceRoot.getPath()); + addKotlinSourceRoot(configuration, kotlinSourceRoot.getPath()); } return createEnvironment(getTestRootDisposable(), configuration); } diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java index 1d6ffe7352e..5cf12145ff5 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.openapi.util.io.FileUtil; import com.intellij.util.ArrayUtil; import com.intellij.util.Processor; +import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; @@ -29,7 +30,6 @@ import org.jetbrains.kotlin.test.TestJdkKind; import java.io.File; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collections; import java.util.List; @@ -69,7 +69,7 @@ public abstract class AbstractTopLevelMembersInvocationTest extends AbstractByte myEnvironment = KotlinCoreEnvironment.createForTests( getTestRootDisposable(), JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, - Arrays.asList(JetTestUtils.getAnnotationsJar()), classPath), + KotlinPackage.plus(classPath, JetTestUtils.getAnnotationsJar()), classPath), EnvironmentConfigFiles.JVM_CONFIG_FILES); loadFiles(ArrayUtil.toStringArray(sourceFiles)); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java b/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java index 01f7c818649..a359d254814 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java @@ -22,8 +22,8 @@ import com.intellij.testFramework.TestDataFile; import com.intellij.testFramework.UsefulTestCase; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.backend.common.output.OutputFile; -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; +import org.jetbrains.kotlin.cli.jvm.config.ConfigPackage; import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils; import org.jetbrains.kotlin.name.FqName; @@ -49,6 +49,7 @@ import java.net.MalformedURLException; import java.net.URL; import java.util.List; +import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.getJvmClasspathRoots; import static org.jetbrains.kotlin.codegen.CodegenTestUtil.*; import static org.jetbrains.kotlin.load.kotlin.PackageClassUtils.getPackageClassFqName; @@ -145,7 +146,7 @@ public abstract class CodegenTestCase extends UsefulTestCase { @NotNull protected URL[] getClassPathURLs() { List urls = Lists.newArrayList(); - for (File file : myEnvironment.getConfiguration().getList(JVMConfigurationKeys.CLASSPATH_KEY)) { + for (File file : getJvmClasspathRoots(myEnvironment.getConfiguration())) { try { urls.add(file.toURI().toURL()); } diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java b/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java index e2f7b49622c..186319c3eee 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java @@ -21,8 +21,8 @@ import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.analyzer.AnalysisResult; -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; +import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys; import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.Progress; diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/GenerateNotNullAssertionsTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/GenerateNotNullAssertionsTest.java index fed991c1b30..d30c89bca3f 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/GenerateNotNullAssertionsTest.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/GenerateNotNullAssertionsTest.java @@ -22,9 +22,9 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.backend.common.output.OutputFile; import org.jetbrains.kotlin.backend.common.output.OutputFileCollection; import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage; -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; +import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys; import org.jetbrains.kotlin.config.CompilerConfiguration; import org.jetbrains.kotlin.load.kotlin.PackageClassUtils; import org.jetbrains.kotlin.name.FqName; diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/TestlibTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/TestlibTest.java index 6f36ee76ca1..1764843b442 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/TestlibTest.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/TestlibTest.java @@ -24,14 +24,12 @@ import junit.framework.TestSuite; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys; import org.jetbrains.kotlin.cli.common.messages.MessageCollectorPlainTextToStream; -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler; import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; -import org.jetbrains.kotlin.config.CommonConfigurationKeys; import org.jetbrains.kotlin.config.CompilerConfiguration; import org.jetbrains.kotlin.descriptors.ClassDescriptor; import org.jetbrains.kotlin.psi.JetClass; @@ -47,6 +45,8 @@ import org.jetbrains.kotlin.types.JetType; import java.io.File; import java.lang.reflect.Modifier; +import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot; +import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot; import static org.jetbrains.kotlin.types.TypeUtils.getAllSupertypes; @SuppressWarnings("JUnitTestCaseWithNoTests") @@ -83,14 +83,14 @@ public class TestlibTest extends UsefulTestCase { super.setUp(); CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.FULL_JDK); - configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, JetTestUtils.getAnnotationsJar()); + addJvmClasspathRoot(configuration, JetTestUtils.getAnnotationsJar()); junitJar = new File("libraries/lib/junit-4.11.jar"); assertTrue(junitJar.exists()); - configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, junitJar); + addJvmClasspathRoot(configuration, junitJar); - configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, JetTestUtils.getHomeDirectory() + "/libraries/stdlib/test"); - configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, JetTestUtils.getHomeDirectory() + "/libraries/kunit/src"); + addKotlinSourceRoot(configuration, JetTestUtils.getHomeDirectory() + "/libraries/stdlib/test"); + addKotlinSourceRoot(configuration, JetTestUtils.getHomeDirectory() + "/libraries/kunit/src"); configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, new MessageCollectorPlainTextToStream(System.out, MessageCollectorPlainTextToStream.NON_VERBOSE)); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java index 5120b288b0d..7263d0877aa 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java @@ -22,7 +22,6 @@ import com.intellij.util.Processor; import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage; -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.codegen.CodegenTestCase; @@ -40,6 +39,7 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; +import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot; import static org.jetbrains.kotlin.codegen.CodegenTestUtil.compileJava; import static org.jetbrains.kotlin.load.kotlin.PackageClassUtils.getPackageClassFqName; @@ -126,7 +126,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase { CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests( ConfigurationKind.ALL, TestJdkKind.FULL_JDK, JetTestUtils.getAnnotationsJar() ); - configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, dirFile); + addJvmClasspathRoot(configuration, dirFile); myEnvironment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); loadFiles(ArrayUtil.toStringArray(ktFilePaths)); classFileFactory = @@ -137,7 +137,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase { // TODO: support several Java sources File javaOut = compileJava(KotlinPackage.single(javaFilePaths), kotlinOut.getPath()); // Add javac output to classpath so that the created class loader can find generated Java classes - configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, javaOut); + addJvmClasspathRoot(configuration, javaOut); blackBox(); } diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java index d1d37b35497..455b1dc74b9 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java @@ -21,11 +21,9 @@ import com.intellij.openapi.util.io.FileUtil; import junit.framework.ComparisonFailure; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.analyzer.AnalysisResult; -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; -import org.jetbrains.kotlin.config.CommonConfigurationKeys; import org.jetbrains.kotlin.config.CompilerConfiguration; import org.jetbrains.kotlin.descriptors.ClassDescriptor; import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; @@ -52,9 +50,14 @@ import org.junit.Assert; import java.io.File; import java.io.FileFilter; import java.io.IOException; -import java.util.*; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Map; import java.util.regex.Pattern; +import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJavaSourceRoot; +import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot; import static org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.*; import static org.jetbrains.kotlin.test.JetTestUtils.*; import static org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesAllowed; @@ -138,8 +141,8 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests( ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, tmpdir); - configuration.put(CommonConfigurationKeys.SOURCE_ROOTS_KEY, Arrays.asList(sourcesDir.getAbsolutePath())); - configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, new File("compiler/tests")); // for @ExpectLoadError annotation + addKotlinSourceRoot(configuration, sourcesDir.getAbsolutePath()); + addJavaSourceRoot(configuration, new File("compiler/tests")); // for @ExpectLoadError annotation KotlinCoreEnvironment environment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/JdkAnnotationsValidityTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/JdkAnnotationsValidityTest.java index b38ab80532f..9a6815b6bc7 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/JdkAnnotationsValidityTest.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/JdkAnnotationsValidityTest.java @@ -27,9 +27,9 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.VirtualFileManager; import com.intellij.openapi.vfs.VirtualFileVisitor; import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; +import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys; import org.jetbrains.kotlin.config.CompilerConfiguration; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.test.ConfigurationKind; diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt index bcb3eb8b012..a5eb89a7d2b 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt @@ -16,32 +16,32 @@ package org.jetbrains.kotlin.jvm.compiler -import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade -import org.jetbrains.kotlin.context.GlobalContext -import org.jetbrains.kotlin.test.JetTestUtils -import com.intellij.testFramework.UsefulTestCase -import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters -import org.jetbrains.kotlin.psi.JetFile -import java.io.File -import com.intellij.psi.search.GlobalSearchScope -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.descriptors.* -import org.junit.Assert -import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment -import org.jetbrains.kotlin.config.CompilerConfiguration -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys -import com.intellij.psi.search.DelegatingGlobalSearchScope import com.intellij.openapi.vfs.VirtualFile -import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModule -import org.jetbrains.kotlin.analyzer.ResolverForProject -import org.jetbrains.kotlin.analyzer.ModuleInfo -import java.util.HashMap +import com.intellij.psi.search.DelegatingGlobalSearchScope +import com.intellij.psi.search.GlobalSearchScope +import com.intellij.testFramework.UsefulTestCase import org.jetbrains.kotlin.analyzer.ModuleContent -import org.jetbrains.kotlin.types.ErrorUtils -import org.jetbrains.kotlin.resolve.descriptorUtil.module +import org.jetbrains.kotlin.analyzer.ModuleInfo +import org.jetbrains.kotlin.analyzer.ResolverForProject +import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoots +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.context.GlobalContext +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.psi.JetFile +import org.jetbrains.kotlin.resolve.descriptorUtil.module +import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade +import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters +import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModule +import org.jetbrains.kotlin.test.JetTestUtils +import org.jetbrains.kotlin.types.ErrorUtils +import org.junit.Assert +import java.io.File +import java.util.HashMap public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() { @@ -71,7 +71,7 @@ public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() { private fun createEnvironment(moduleDirs: Array): KotlinCoreEnvironment { val configuration = CompilerConfiguration() - configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, moduleDirs.toList()) + configuration.addJavaSourceRoots(moduleDirs.toList()) return KotlinCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) } diff --git a/compiler/tests/org/jetbrains/kotlin/scripts/ScriptTest.java b/compiler/tests/org/jetbrains/kotlin/scripts/ScriptTest.java index 70d3681bffe..57657ad5cf9 100644 --- a/compiler/tests/org/jetbrains/kotlin/scripts/ScriptTest.java +++ b/compiler/tests/org/jetbrains/kotlin/scripts/ScriptTest.java @@ -23,10 +23,10 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys; import org.jetbrains.kotlin.cli.common.messages.*; -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler; +import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys; import org.jetbrains.kotlin.codegen.CompilationException; import org.jetbrains.kotlin.config.CommonConfigurationKeys; import org.jetbrains.kotlin.config.CompilerConfiguration; @@ -45,6 +45,8 @@ import org.junit.Test; import java.util.Collections; import java.util.List; +import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot; + public class ScriptTest { @Test public void testScript() throws Exception { @@ -82,7 +84,7 @@ public class ScriptTest { CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.FULL_JDK); configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector); - configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, "compiler/testData/script/" + scriptPath); + addKotlinSourceRoot(configuration, "compiler/testData/script/" + scriptPath); configuration.addAll(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY, scriptDefinitions); configuration.put(JVMConfigurationKeys.SCRIPT_PARAMETERS, scriptParameters); diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt index 33a28358d9e..86583ba144d 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt @@ -23,8 +23,8 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys import org.jetbrains.kotlin.cli.common.messages.MessageCollector 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.config.CompilerConfiguration +import org.jetbrains.kotlin.config.addKotlinSourceRoots import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS @@ -52,8 +52,7 @@ public class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() { val configuration = CompilerConfiguration() configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE) - val sourceRoots = srcDirs map { it.path } - configuration.put(CommonConfigurationKeys.SOURCE_ROOTS_KEY, sourceRoots) + configuration.addKotlinSourceRoots(srcDirs map { it.path }) serialize(configuration, metaFile) val module = deserialize(metaFile) diff --git a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java b/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java index e839622533e..df62a21f8a5 100644 --- a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java @@ -51,6 +51,8 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime; 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.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.kotlin.diagnostics.Diagnostic; import org.jetbrains.kotlin.diagnostics.Errors; @@ -85,8 +87,10 @@ import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; -import static org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys.ANNOTATIONS_PATH_KEY; -import static org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys.CLASSPATH_KEY; +import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJavaSourceRoots; +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.cli.jvm.config.JVMConfigurationKeys.ANNOTATIONS_PATH_KEY; import static org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetAnalysisResult; import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.kotlin.test.ConfigurationKind.ALL; @@ -407,25 +411,25 @@ public class JetTestUtils { public static CompilerConfiguration compilerConfigurationForTests( @NotNull ConfigurationKind configurationKind, @NotNull TestJdkKind jdkKind, - @NotNull Collection extraClasspath, - @NotNull Collection priorityClasspath + @NotNull List classpath, + @NotNull List javaSource ) { CompilerConfiguration configuration = new CompilerConfiguration(); - configuration.addAll(CLASSPATH_KEY, priorityClasspath); + addJavaSourceRoots(configuration, javaSource); if (jdkKind == TestJdkKind.MOCK_JDK) { - configuration.add(CLASSPATH_KEY, findMockJdkRtJar()); + addJvmClasspathRoot(configuration, findMockJdkRtJar()); } else if (jdkKind == TestJdkKind.ANDROID_API) { - configuration.add(CLASSPATH_KEY, findAndroidApiJar()); + addJvmClasspathRoot(configuration, findAndroidApiJar()); } else { - configuration.addAll(CLASSPATH_KEY, PathUtil.getJdkClassesRoots()); + addJvmClasspathRoots(configuration, PathUtil.getJdkClassesRoots()); } if (configurationKind == ALL) { - configuration.add(CLASSPATH_KEY, ForTestCompileRuntime.runtimeJarForTests()); - configuration.add(CLASSPATH_KEY, ForTestCompileRuntime.reflectJarForTests()); + addJvmClasspathRoot(configuration, ForTestCompileRuntime.runtimeJarForTests()); + addJvmClasspathRoot(configuration, ForTestCompileRuntime.reflectJarForTests()); } - configuration.addAll(CLASSPATH_KEY, extraClasspath); + addJvmClasspathRoots(configuration, classpath); if (configurationKind == ALL || configurationKind == JDK_AND_ANNOTATIONS) { if (jdkKind == TestJdkKind.ANDROID_API) { @@ -440,10 +444,13 @@ public class JetTestUtils { } public static void resolveAllKotlinFiles(KotlinCoreEnvironment environment) throws IOException { - List paths = environment.getConfiguration().get(CommonConfigurationKeys.SOURCE_ROOTS_KEY); + List paths = environment.getConfiguration().get(CommonConfigurationKeys.CONTENT_ROOTS); if (paths == null) return; List jetFiles = Lists.newArrayList(); - for (String path : paths) { + for (ContentRoot root : paths) { + if (!(root instanceof KotlinSourceRoot)) continue; + + String path = ((KotlinSourceRoot) root).getPath(); File file = new File(path); if (file.isFile()) { jetFiles.add(loadJetFile(environment.getProject(), file)); diff --git a/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt b/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt index 47bd69a9f20..246d172a01a 100644 --- a/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt +++ b/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt @@ -20,7 +20,7 @@ import org.junit.Test import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import com.intellij.openapi.util.Disposer -import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils @@ -32,7 +32,7 @@ import org.jetbrains.kotlin.utils.PathUtil import org.jetbrains.kotlin.resolve.DescriptorUtils import java.util.HashSet import org.jetbrains.kotlin.config.CommonConfigurationKeys -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys +import org.jetbrains.kotlin.cli.jvm.config.* import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.resolve.BindingTraceContext @@ -118,9 +118,9 @@ class NoInternalVisibilityInStdLibTest { Test fun testJvmStdlib() { doTest(ANALYZE_PACKAGE_ROOTS_FOR_JVM, ADDITIONALLY_REQUIRED_PACKAGES_FOR_JVM) { val configuration = CompilerConfiguration() - configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, "../src/kotlin") - configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, "../src/generated") - configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots()) + configuration.addKotlinSourceRoot("../src/kotlin") + configuration.addKotlinSourceRoot("../src/generated") + configuration.addJvmClasspathRoots(PathUtil.getJdkClassesRoots()) val environment = KotlinCoreEnvironment.createForProduction(disposable!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) diff --git a/libraries/tools/kdoc/src/test/kotlin/test/kotlin/psiUtilsTest.kt b/libraries/tools/kdoc/src/test/kotlin/test/kotlin/psiUtilsTest.kt index 0184d07fda9..98f261e05aa 100644 --- a/libraries/tools/kdoc/src/test/kotlin/test/kotlin/psiUtilsTest.kt +++ b/libraries/tools/kdoc/src/test/kotlin/test/kotlin/psiUtilsTest.kt @@ -1,6 +1,6 @@ package test.kotlin -import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys +import org.jetbrains.kotlin.cli.jvm.config.* import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.kotlin.config.CompilerConfiguration @@ -33,7 +33,7 @@ class PsiUtilsTest { System.setProperty("java.awt.headless", "true") val configuration = CompilerConfiguration() - configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots()) + configuration.addJvmClasspathRoots(PathUtil.getJdkClassesRoots()) environment = KotlinCoreEnvironment.createForTests(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) }