azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

JPS: switch to using *CompilerArgument classes(from IDEA Project Settings) in build.

Browse Source
This commit is contained in:
Zalim Bashorov
2013-10-11 15:48:36 +04:00
parent 0877dfc1bd
commit 5e0ef68d64
7 changed files with 137 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ide-compiler-runner/src/org/jetbrains/jet/compiler/runner/CompilerRunnerUtil.java
+37 -7
View File
@@ -17,8 +17,10 @@
package org.jetbrains.jet.compiler.runner;
import com.intellij.util.Function;
import com.intellij.util.xmlb.XmlSerializer;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.cli.common.messages.*;
import org.jetbrains.jet.cli.common.arguments.CompilerArguments;
import org.jetbrains.jet.cli.common.messages.MessageCollector;
import org.jetbrains.jet.preloading.ClassPreloadingUtils;
import org.jetbrains.jet.utils.KotlinPaths;
@@ -29,13 +31,17 @@ import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static org.jetbrains.jet.cli.common.messages.CompilerMessageLocation.NO_LOCATION;
import static org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity.*;
import static org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity.ERROR;
public class CompilerRunnerUtil {
private static final String STRING_ARRAY_CLASS_NAME = String[].class.getName();
private static final String COMPILER_ARGUMENTS_CLASS_NAME = CompilerArguments.class.getName();
private static SoftReference<ClassLoader> ourClassLoaderRef = new SoftReference<ClassLoader>(null);
public static List<File> kompilerClasspath(KotlinPaths paths, MessageCollector messageCollector) {
@@ -106,15 +112,34 @@ public class CompilerRunnerUtil {
}
public static Object invokeExecMethod(
String className, String[] arguments, CompilerEnvironment environment,
String compilerClassName, CompilerArguments arguments, CompilerEnvironment environment,
MessageCollector messageCollector, PrintStream out, boolean usePreloader
) throws Exception {
return invokeExecMethod(compilerClassName, COMPILER_ARGUMENTS_CLASS_NAME, arguments, environment, messageCollector, out, usePreloader);
}
public static Object invokeExecMethod(
String compilerClassName, String[] arguments, CompilerEnvironment environment,
MessageCollector messageCollector, PrintStream out, boolean usePreloader
) throws Exception {
return invokeExecMethod(compilerClassName, STRING_ARRAY_CLASS_NAME, arguments, environment, messageCollector, out, usePreloader);
}
public static <T> Object invokeExecMethod(
String compilerClassName, String argumentsClassName, T arguments, CompilerEnvironment environment,
MessageCollector messageCollector, PrintStream out, boolean usePreloader
) throws Exception {
ClassLoader loader = usePreloader
? getOrCreatePreloader(environment.getKotlinPaths(), messageCollector)
: getOrCreateClassLoader(environment.getKotlinPaths(), messageCollector);
Class<?> kompiler = Class.forName(className, true, loader);
Method exec = kompiler.getMethod("exec", PrintStream.class, String[].class);
return exec.invoke(kompiler.newInstance(), out, arguments);
Class<?> argumentsClass = Class.forName(argumentsClassName, true, loader);
Object argumentsInLoader = copyObject(arguments, loader);
Class<?> kompiler = Class.forName(compilerClassName, true, loader);
Method exec = kompiler.getMethod("exec", PrintStream.class, argumentsClass);
return exec.invoke(kompiler.newInstance(), out, argumentsInLoader);
}
public static void outputCompilerMessagesAndHandleExitCode(@NotNull MessageCollector messageCollector,
@@ -129,4 +154,9 @@ public class CompilerRunnerUtil {
CompilerOutputParser.parseCompilerMessagesFromReader(messageCollector, reader, outputItemsCollector);
handleProcessTermination(exitCode, messageCollector);
}
private static Object copyObject(Object object, ClassLoader loader) throws ClassNotFoundException {
Class<?> objectClassInLoader = Class.forName(object.getClass().getName(), true, loader);
return XmlSerializer.deserialize(XmlSerializer.serialize(object), objectClassInLoader);
}
}
ide-compiler-runner/src/org/jetbrains/jet/compiler/runner/KotlinCompilerRunner.java
+61 -34
View File
@@ -16,9 +16,14 @@
package org.jetbrains.jet.compiler.runner;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.util.ArrayUtil;
import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.xmlb.Accessor;
import com.intellij.util.xmlb.XmlSerializerUtil;
import org.jetbrains.jet.cli.common.arguments.CommonCompilerArguments;
import org.jetbrains.jet.cli.common.arguments.K2JSCompilerArguments;
import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments;
import org.jetbrains.jet.cli.common.messages.CompilerMessageLocation;
import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity;
import org.jetbrains.jet.cli.common.messages.MessageCollector;
@@ -26,23 +31,30 @@ import org.jetbrains.jet.cli.common.messages.MessageCollectorUtil;
import java.io.File;
import java.io.PrintStream;
import java.util.*;
import java.util.List;
import java.util.Set;
public class KotlinCompilerRunner {
private static final String K2JVM_COMPILER = "org.jetbrains.jet.cli.jvm.K2JVMCompiler";
private static final String K2JS_COMPILER = "org.jetbrains.jet.cli.js.K2JSCompiler";
public static void runK2JvmCompiler(
CommonCompilerArguments commonArguments,
K2JVMCompilerArguments k2jvmArguments,
MessageCollector messageCollector,
CompilerEnvironment environment,
File moduleFile,
OutputItemsCollector collector
) {
String[] arguments = createArgumentsForJvmCompiler(moduleFile);
K2JVMCompilerArguments arguments = mergeBeans(commonArguments, k2jvmArguments);
setupK2JvmSettings(moduleFile, arguments);
runCompiler(K2JVM_COMPILER, arguments, messageCollector, collector, environment);
}
public static void runK2JsCompiler(
CommonCompilerArguments commonArguments,
K2JSCompilerArguments k2jsArguments,
MessageCollector messageCollector,
CompilerEnvironment environment,
OutputItemsCollector collector,
@@ -50,13 +62,15 @@ public class KotlinCompilerRunner {
Set<String> libraryFiles,
File outputFile
) {
String[] arguments = createArgumentsForJsCompiler(outputFile, sourceFiles, libraryFiles);
K2JSCompilerArguments arguments = mergeBeans(commonArguments, k2jsArguments);
setupK2JsSettings(outputFile, sourceFiles, libraryFiles, arguments);
runCompiler(K2JS_COMPILER, arguments, messageCollector, collector, environment);
}
private static void runCompiler(
final String compilerClassName,
final String[] arguments,
final CommonCompilerArguments arguments,
final MessageCollector messageCollector,
OutputItemsCollector collector,
final CompilerEnvironment environment
@@ -71,7 +85,7 @@ public class KotlinCompilerRunner {
private static int execCompiler(
String compilerClassName,
String[] arguments,
CommonCompilerArguments arguments,
CompilerEnvironment environment,
PrintStream out,
MessageCollector messageCollector
@@ -80,9 +94,7 @@ public class KotlinCompilerRunner {
messageCollector.report(CompilerMessageSeverity.INFO,
"Using kotlinHome=" + environment.getKotlinPaths().getHomePath(),
CompilerMessageLocation.NO_LOCATION);
messageCollector.report(CompilerMessageSeverity.INFO,
"Invoking in-process compiler " + compilerClassName + " with arguments " + Arrays.asList(arguments),
CompilerMessageLocation.NO_LOCATION);
Object rc = CompilerRunnerUtil.invokeExecMethod(compilerClassName, arguments, environment,
messageCollector, out, /*usePreloader=*/true);
// exec() returns a K2JVMCompiler.ExitCode object, that class is not accessible here,
@@ -95,40 +107,55 @@ public class KotlinCompilerRunner {
}
}
private static String[] createArgumentsForJvmCompiler(File moduleFile) {
return new String[]{
"-module", moduleFile.getAbsolutePath(),
"-tags", "-verbose", "-version",
"-notNullAssertions", "-notNullParamAssertions",
"-noStdlib", "-noJdkAnnotations", "-noJdk"};
private static <F, T extends F> T mergeBeans(F from, T to) {
T copy = XmlSerializerUtil.createCopy(to);
for (Accessor accessor : XmlSerializerUtil.getAccessors(from.getClass())) {
accessor.write(copy, accessor.read(from));
}
return copy;
}
private static String[] createArgumentsForJsCompiler(
private static void setupCommonSettings(CommonCompilerArguments settings) {
settings.tags = true;
settings.verbose = true;
settings.version = true;
settings.printArgs = true;
}
private static void setupK2JvmSettings(
File moduleFile,
K2JVMCompilerArguments settings
) {
setupCommonSettings(settings);
settings.module = moduleFile.getAbsolutePath();
settings.notNullAssertions = true;
settings.notNullParamAssertions = true;
settings.noStdlib = true;
settings.noJdkAnnotations = true;
settings.noJdk = true;
}
private static void setupK2JsSettings(
File outputFile,
List<File> sourceFiles,
Set<String> libraryFiles
Set<String> libraryFiles,
K2JSCompilerArguments settings
) {
List<String> args = new ArrayList<String>();
setupCommonSettings(settings);
Collections.addAll(args, "-tags", "-verbose", "-version", "-sourcemap");
String separator = ",";
String sourceFilesAsString = StringUtil.join(sourceFiles, new Function<File, String>() {
List<String> sourceFilePaths = ContainerUtil.map(sourceFiles, new Function<File, String>() {
@Override
public String fun(File file) {
return file.getPath();
}
}, separator);
args.add("-sourceFiles");
args.add(sourceFilesAsString);
args.add("-output");
args.add(outputFile.getPath());
args.add("-libraryFiles");
args.add(StringUtil.join(libraryFiles, separator));
return ArrayUtil.toStringArray(args);
});
settings.sourceFiles = ArrayUtil.toStringArray(sourceFilePaths);
settings.outputFile = outputFile.getPath();
settings.libraryFiles = ArrayUtil.toStringArray(libraryFiles);
//TODO drop later
settings.sourcemap = true;
}
}
idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java
+11 -1
View File
@@ -31,6 +31,7 @@ import com.intellij.util.Chunk;
import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments;
import org.jetbrains.jet.cli.common.messages.MessageCollector;
import org.jetbrains.jet.compiler.runner.*;
import org.jetbrains.jet.plugin.JetFileType;
@@ -133,7 +134,16 @@ public class JetCompiler implements TranslatingCompiler {
File scriptFile,
OutputItemsCollector outputItemsCollector
) {
KotlinCompilerRunner.runK2JvmCompiler(messageCollector, environment, scriptFile, outputItemsCollector);
K2JVMCompilerArguments commonArguments = new K2JVMCompilerArguments();
commonArguments.verbose = true;
commonArguments.tags = true;
commonArguments.printArgs = true;
commonArguments.version = true;
K2JVMCompilerArguments jvmArguments = new K2JVMCompilerArguments();
jvmArguments.module = scriptFile.getAbsolutePath();
KotlinCompilerRunner.runK2JvmCompiler(commonArguments, jvmArguments, messageCollector, environment, scriptFile, outputItemsCollector);
}
public static File tryToWriteScriptFile(
idea/src/org/jetbrains/jet/plugin/compiler/configuration/KotlinCompilerConfigurableTab.java
+1 -1
View File
@@ -91,7 +91,7 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
}
private boolean isGenerateNoWarnings() {
return SUPPRESS_WARNINGS.equals(commonCompilerSettings.suppress);
return commonCompilerSettings.suppressAllWarnings();
}
private void setGenerateNoWarnings(boolean selected) {
idea/tests/org/jetbrains/jet/plugin/compilerMessages/JetCompilerMessagingTest.java
+1 -1
View File
@@ -81,7 +81,7 @@ public final class JetCompilerMessagingTest extends IDECompilerMessagingTest {
@Override
protected void checkHeader(@NotNull MessageChecker checker) {
checker.expect(Message.info().textStartsWith("Using kotlinHome="));
checker.expect(Message.info().textStartsWith("Invoking in-process compiler"));
checker.expect(Message.info().textStartsWith("Invoking compiler"));
checker.expect(Message.info().textStartsWith("Kotlin Compiler version"));
checker.expect(Message.stats().textStartsWith("Using Kotlin home directory"));
checker.expect(Message.stats().text("Configuring the compilation environment"));
jps-plugin/src/org/jetbrains/jet/jps/JpsKotlinCompilerSettings.java
+8 -31
View File
@@ -16,8 +16,6 @@
package org.jetbrains.jet.jps;
import com.intellij.util.xmlb.Accessor;
import com.intellij.util.xmlb.XmlSerializerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.cli.common.arguments.CommonCompilerArguments;
import org.jetbrains.jet.cli.common.arguments.K2JSCompilerArguments;
@@ -73,49 +71,28 @@ public class JpsKotlinCompilerSettings extends JpsElementBase<JpsKotlinCompilerS
@NotNull
public static CommonCompilerArguments getCommonSettings(@NotNull JpsProject project) {
JpsKotlinCompilerSettings settings = getSettings(project);
return settings.commonCompilerSettings;
return getSettings(project).commonCompilerSettings;
}
public static void setCommonSettings(@NotNull JpsProject project, @NotNull CommonCompilerArguments commonCompilerSettings) {
JpsKotlinCompilerSettings settings = getOrCreateSettings(project);
settings.commonCompilerSettings = commonCompilerSettings;
getOrCreateSettings(project).commonCompilerSettings = commonCompilerSettings;
}
@NotNull
public static K2JVMCompilerArguments getMergedK2JvmSettings(@NotNull JpsProject project) {
JpsKotlinCompilerSettings settings = getSettings(project);
return merge(settings.commonCompilerSettings, settings.k2JvmCompilerSettings);
public static K2JVMCompilerArguments getK2JvmSettings(@NotNull JpsProject project) {
return getSettings(project).k2JvmCompilerSettings;
}
public static void setK2JvmSettings(@NotNull JpsProject project, @NotNull K2JVMCompilerArguments k2JvmCompilerSettings) {
JpsKotlinCompilerSettings settings = getOrCreateSettings(project);
settings.k2JvmCompilerSettings = k2JvmCompilerSettings;
getOrCreateSettings(project).k2JvmCompilerSettings = k2JvmCompilerSettings;
}
@NotNull
public static K2JSCompilerArguments getMergedK2JsSettings(@NotNull JpsProject project) {
JpsKotlinCompilerSettings settings = getSettings(project);
return merge(settings.commonCompilerSettings, settings.k2JsCompilerSettings);
public static K2JSCompilerArguments getK2JsSettings(@NotNull JpsProject project) {
return getSettings(project).k2JsCompilerSettings;
}
public static void setK2JsSettings(@NotNull JpsProject project, @NotNull K2JSCompilerArguments k2JsCompilerSettings) {
JpsKotlinCompilerSettings settings = getOrCreateSettings(project);
settings.k2JsCompilerSettings = k2JsCompilerSettings;
}
@NotNull
private static <T extends CommonCompilerArguments> T merge(@NotNull CommonCompilerArguments from, @NotNull T to) {
Class<CommonCompilerArguments> fromClass = CommonCompilerArguments.class;
assert fromClass.isAssignableFrom(to.getClass()) : to.getClass() + " is not assignable to " + fromClass;
T mergedCopy = XmlSerializerUtil.createCopy(to);
for (Accessor accessor : XmlSerializerUtil.getAccessors(fromClass)) {
accessor.write(mergedCopy, accessor.read(from));
}
return mergedCopy;
getOrCreateSettings(project).k2JsCompilerSettings = k2JsCompilerSettings;
}
}
jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilder.java
+18 -12
View File
@@ -21,10 +21,14 @@ import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.cli.common.KotlinVersion;
import org.jetbrains.jet.cli.common.arguments.CommonCompilerArguments;
import org.jetbrains.jet.cli.common.arguments.K2JSCompilerArguments;
import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments;
import org.jetbrains.jet.cli.common.messages.CompilerMessageLocation;
import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity;
import org.jetbrains.jet.cli.common.messages.MessageCollector;
import org.jetbrains.jet.compiler.runner.*;
import org.jetbrains.jet.jps.JpsKotlinCompilerSettings;
import org.jetbrains.jet.utils.PathUtil;
import org.jetbrains.jps.ModuleChunk;
import org.jetbrains.jps.builders.DirtyFilesHolder;
@@ -33,6 +37,7 @@ import org.jetbrains.jps.incremental.*;
import org.jetbrains.jps.incremental.java.JavaBuilder;
import org.jetbrains.jps.incremental.messages.BuildMessage;
import org.jetbrains.jps.incremental.messages.CompilerMessage;
import org.jetbrains.jps.model.JpsProject;
import org.jetbrains.jps.model.module.JpsModule;
import java.io.File;
@@ -42,11 +47,15 @@ import java.lang.reflect.Modifier;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import static org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity.EXCEPTION;
import static org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity.INFO;
import static org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity.WARNING;
import static org.jetbrains.jet.compiler.runner.KotlinCompilerRunner.runK2JsCompiler;
import static org.jetbrains.jet.compiler.runner.KotlinCompilerRunner.runK2JvmCompiler;
public class KotlinBuilder extends ModuleLevelBuilder {
private static final String KOTLIN_BUILDER_NAME = "Kotlin Builder";
@@ -104,6 +113,9 @@ public class KotlinBuilder extends ModuleLevelBuilder {
OutputItemsCollectorImpl outputItemCollector = new OutputItemsCollectorImpl(outputDir);
JpsProject project = representativeTarget.getModule().getProject();
CommonCompilerArguments commonSettings = JpsKotlinCompilerSettings.getCommonSettings(project);
if (JpsUtils.isJsKotlinModule(representativeTarget)) {
if (chunk.getModules().size() > 1) {
// We do not support circular dependencies, but if they are present, we do our best should not break the build,
@@ -124,14 +136,10 @@ public class KotlinBuilder extends ModuleLevelBuilder {
}
File outputFile = new File(outputDir, representativeTarget.getModule().getName() + ".js");
Set<String> libraryFiles = JpsJsModuleUtils.getLibraryFilesAndDependencies(representativeTarget);
K2JSCompilerArguments k2JsSettings = JpsKotlinCompilerSettings.getK2JsSettings(project);
KotlinCompilerRunner.runK2JsCompiler(
messageCollector,
environment,
outputItemCollector,
sourceFiles,
JpsJsModuleUtils.getLibraryFilesAndDependencies(representativeTarget),
outputFile);
runK2JsCompiler(commonSettings, k2JsSettings, messageCollector, environment, outputItemCollector, sourceFiles, libraryFiles, outputFile);
}
else {
if (chunk.getModules().size() > 1) {
@@ -148,11 +156,9 @@ public class KotlinBuilder extends ModuleLevelBuilder {
return ExitCode.NOTHING_DONE;
}
KotlinCompilerRunner.runK2JvmCompiler(
messageCollector,
environment,
moduleFile,
outputItemCollector);
K2JVMCompilerArguments k2JvmSettings = JpsKotlinCompilerSettings.getK2JvmSettings(project);
runK2JvmCompiler(commonSettings, k2JvmSettings, messageCollector, environment, moduleFile, outputItemCollector);
}
for (SimpleOutputItem outputItem : outputItemCollector.getOutputs()) {