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

ide-compiler-runner/src/org/jetbrains/jet/compiler/runner/CompilerRunnerUtil.java

@@ -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);
+        Class<?> argumentsClass = Class.forName(argumentsClassName, true, loader);
-        return exec.invoke(kompiler.newInstance(), out, arguments);
+        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

@@ -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) {
+    private static <F, T extends F> T mergeBeans(F from, T to) {
-        return new String[]{
+        T copy = XmlSerializerUtil.createCopy(to);
-                "-module", moduleFile.getAbsolutePath(),
+
-                "-tags", "-verbose", "-version",
+        for (Accessor accessor : XmlSerializerUtil.getAccessors(from.getClass())) {
-                "-notNullAssertions", "-notNullParamAssertions",
+            accessor.write(copy, accessor.read(from));
-                "-noStdlib", "-noJdkAnnotations", "-noJdk"};
+        }
+
+        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");
+        List<String> sourceFilePaths = ContainerUtil.map(sourceFiles, new Function<File, String>() {
-
-        String separator = ",";
-        String sourceFilesAsString = StringUtil.join(sourceFiles, new Function<File, String>() {
             @Override
             public String fun(File file) {
                 return file.getPath();
             }
-        }, separator);
+        });
-
+        settings.sourceFiles = ArrayUtil.toStringArray(sourceFilePaths);
-        args.add("-sourceFiles");
+        settings.outputFile = outputFile.getPath();
-        args.add(sourceFilesAsString);
+        settings.libraryFiles = ArrayUtil.toStringArray(libraryFiles);
-
+        //TODO drop later
-        args.add("-output");
+        settings.sourcemap = true;
-        args.add(outputFile.getPath());
-
-        args.add("-libraryFiles");
-        args.add(StringUtil.join(libraryFiles, separator));
-
-        return ArrayUtil.toStringArray(args);
     }
 }

idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java

@@ -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

@@ -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

@@ -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

@@ -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 getSettings(project).commonCompilerSettings;
-        return settings.commonCompilerSettings;
     }
 
     public static void setCommonSettings(@NotNull JpsProject project, @NotNull CommonCompilerArguments commonCompilerSettings) {
-        JpsKotlinCompilerSettings settings = getOrCreateSettings(project);
+        getOrCreateSettings(project).commonCompilerSettings = commonCompilerSettings;
-        settings.commonCompilerSettings = commonCompilerSettings;
     }
 
     @NotNull
-    public static K2JVMCompilerArguments getMergedK2JvmSettings(@NotNull JpsProject project) {
+    public static K2JVMCompilerArguments getK2JvmSettings(@NotNull JpsProject project) {
-        JpsKotlinCompilerSettings settings = getSettings(project);
+        return getSettings(project).k2JvmCompilerSettings;
-        return merge(settings.commonCompilerSettings, settings.k2JvmCompilerSettings);
     }
 
     public static void setK2JvmSettings(@NotNull JpsProject project, @NotNull K2JVMCompilerArguments k2JvmCompilerSettings) {
-        JpsKotlinCompilerSettings settings = getOrCreateSettings(project);
+        getOrCreateSettings(project).k2JvmCompilerSettings = k2JvmCompilerSettings;
-        settings.k2JvmCompilerSettings = k2JvmCompilerSettings;
     }
 
     @NotNull
-    public static K2JSCompilerArguments getMergedK2JsSettings(@NotNull JpsProject project) {
+    public static K2JSCompilerArguments getK2JsSettings(@NotNull JpsProject project) {
-        JpsKotlinCompilerSettings settings = getSettings(project);
+        return getSettings(project).k2JsCompilerSettings;
-        return merge(settings.commonCompilerSettings, settings.k2JsCompilerSettings);
     }
 
     public static void setK2JsSettings(@NotNull JpsProject project, @NotNull K2JSCompilerArguments k2JsCompilerSettings) {
-        JpsKotlinCompilerSettings settings = getOrCreateSettings(project);
+        getOrCreateSettings(project).k2JsCompilerSettings = k2JsCompilerSettings;
-        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;
     }
 }

jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilder.java

@@ -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(
+            runK2JsCompiler(commonSettings, k2JsSettings, messageCollector, environment, outputItemCollector, sourceFiles, libraryFiles, outputFile);
-                    messageCollector,
-                    environment,
-                    outputItemCollector,
-                    sourceFiles,
-                    JpsJsModuleUtils.getLibraryFilesAndDependencies(representativeTarget),
-                    outputFile);
         }
         else {
             if (chunk.getModules().size() > 1) {
@@ -148,11 +156,9 @@ public class KotlinBuilder extends ModuleLevelBuilder {
                 return ExitCode.NOTHING_DONE;
             }
 
-            KotlinCompilerRunner.runK2JvmCompiler(
+            K2JVMCompilerArguments k2JvmSettings = JpsKotlinCompilerSettings.getK2JvmSettings(project);
-                    messageCollector,
+
-                    environment,
+            runK2JvmCompiler(commonSettings, k2JvmSettings, messageCollector, environment, moduleFile, outputItemCollector);
-                    moduleFile,
-                    outputItemCollector);
         }
 
         for (SimpleOutputItem outputItem : outputItemCollector.getOutputs()) {