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

Original commit: 5e0ef68d64

jps/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/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()) {