Pass arguments to the compiler as String[] instead of Object (instanceof CommonCompilerArguments).

compiler/cli/cli-common/src/com/sampullara/cli/ArgumentUtils.java

@@ -20,22 +20,28 @@ import com.intellij.util.containers.ComparatorUtil;
 import org.jetbrains.annotations.NotNull;
 
 import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
 
 public class ArgumentUtils {
 
     private ArgumentUtils() {}
 
     @NotNull
-    public static <T> String convertArgumentsToString(T arguments, T defaultArguments) {
+    public static <T> List<String> convertArgumentsToStringList(@NotNull T arguments, @NotNull T defaultArguments) {
-        StringBuilder result = new StringBuilder();
+        List<String> result = new ArrayList<String>();
-        convertArgumentsToString(arguments, defaultArguments, arguments.getClass(), result);
+        convertArgumentsToStringList(arguments, defaultArguments, result);
-        return result.toString();
+        return result;
     }
 
-    public static <T> void convertArgumentsToString(T arguments, T defaultArguments, Class clazz, StringBuilder result) {
+    public static <T> void convertArgumentsToStringList(@NotNull T arguments, @NotNull T defaultArguments, @NotNull List<String> result) {
+        convertArgumentsToStringList(arguments, defaultArguments, arguments.getClass(), result);
+    }
+
+    private static <T> void convertArgumentsToStringList(T arguments, T defaultArguments, Class clazz, List<String> result) {
         Class superClazz = clazz.getSuperclass();
         if (superClazz != null) {
-            convertArgumentsToString(arguments, defaultArguments, superClazz, result);
+            convertArgumentsToStringList(arguments, defaultArguments, superClazz, result);
         }
 
         for (Field field : clazz.getDeclaredFields()) {
@@ -60,11 +66,11 @@ public class ArgumentUtils {
                 name = Args.getName(argument, field);
             }
 
-            result.append("-").append(name).append(" ");
+            result.add(argument.prefix() + name);
 
             Class<?> fieldType = field.getType();
             if (fieldType != boolean.class && fieldType != Boolean.class) {
-                result.append(value).append(" ");
+                result.add(value.toString());
             }
         }
     }

compiler/cli/src/org/jetbrains/jet/cli/common/CLICompiler.java

@@ -189,11 +189,14 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> {
             @NotNull MessageRenderer messageRenderer
     ) {
         if (arguments.printArgs) {
-            String freeArgs = StringUtil.join(arguments.freeArgs, "");
+            String freeArgs = StringUtil.join(arguments.freeArgs, " ");
-            String argumentsAsString = ArgumentUtils.convertArgumentsToString(arguments, createArguments());
+
+            List<String> argumentsAsList = ArgumentUtils.convertArgumentsToStringList(arguments, createArguments());
+            String argumentsAsString = StringUtil.join(argumentsAsList, " ");
+
             String printArgsMessage = messageRenderer.render(CompilerMessageSeverity.INFO,
                                                              "Invoking compiler " + getClass().getName() +
-                                                             " with arguments " + argumentsAsString + freeArgs,
+                                                             " with arguments " + argumentsAsString + " " + freeArgs,
                                                              CompilerMessageLocation.NO_LOCATION);
             errStream.println(printArgsMessage);
         }

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

@@ -17,9 +17,7 @@
 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.arguments.CommonCompilerArguments;
 import org.jetbrains.jet.cli.common.messages.MessageCollector;
 import org.jetbrains.jet.preloading.ClassPreloadingUtils;
 import org.jetbrains.jet.utils.KotlinPaths;
@@ -40,8 +38,6 @@ import static org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity.ERRO
 
 public class CompilerRunnerUtil {
 
-    private static final String STRING_ARRAY_CLASS_NAME = String[].class.getName();
-    private static final String COMPILER_ARGUMENTS_CLASS_NAME = CommonCompilerArguments.class.getName();
     private static SoftReference<ClassLoader> ourClassLoaderRef = new SoftReference<ClassLoader>(null);
 
     public static List<File> kompilerClasspath(KotlinPaths paths, MessageCollector messageCollector) {
@@ -111,35 +107,18 @@ public class CompilerRunnerUtil {
         }
     }
 
-    public static Object invokeExecMethod(
-            String compilerClassName, CommonCompilerArguments 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<?> 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);
+        Method exec = kompiler.getMethod("exec", PrintStream.class,  String[].class);
 
-        return exec.invoke(kompiler.newInstance(), out, argumentsInLoader);
+        return exec.invoke(kompiler.newInstance(), out, arguments);
     }
 
     public static void outputCompilerMessagesAndHandleExitCode(@NotNull MessageCollector messageCollector,
@@ -154,9 +133,4 @@ 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

@@ -21,6 +21,7 @@ import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.xmlb.Accessor;
 import com.intellij.util.xmlb.XmlSerializerUtil;
+import com.sampullara.cli.ArgumentUtils;
 import org.jetbrains.jet.cli.common.arguments.CommonCompilerArguments;
 import org.jetbrains.jet.cli.common.arguments.K2JSCompilerArguments;
 import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments;
@@ -37,6 +38,8 @@ 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";
+    private static final K2JVMCompilerArguments DEFAULT_K2JVM_ARGUMENTS = new K2JVMCompilerArguments();
+    private static final K2JSCompilerArguments DEFAULT_K2JS_ARGUMENTS = new K2JSCompilerArguments();
 
     public static void runK2JvmCompiler(
             CommonCompilerArguments commonArguments,
@@ -49,7 +52,7 @@ public class KotlinCompilerRunner {
         K2JVMCompilerArguments arguments = mergeBeans(commonArguments, k2jvmArguments);
         setupK2JvmSettings(moduleFile, arguments);
 
-        runCompiler(K2JVM_COMPILER, arguments, messageCollector, collector, environment);
+        runCompiler(K2JVM_COMPILER, arguments, DEFAULT_K2JVM_ARGUMENTS, messageCollector, collector, environment);
     }
 
     public static void runK2JsCompiler(
@@ -65,27 +68,30 @@ public class KotlinCompilerRunner {
         K2JSCompilerArguments arguments = mergeBeans(commonArguments, k2jsArguments);
         setupK2JsSettings(outputFile, sourceFiles, libraryFiles, arguments);
 
-        runCompiler(K2JS_COMPILER, arguments, messageCollector, collector, environment);
+        runCompiler(K2JS_COMPILER, arguments, DEFAULT_K2JS_ARGUMENTS, messageCollector, collector, environment);
     }
 
     private static void runCompiler(
             final String compilerClassName,
-            final CommonCompilerArguments arguments,
+            CommonCompilerArguments arguments,
+            CommonCompilerArguments defaultArguments,
             final MessageCollector messageCollector,
             OutputItemsCollector collector,
             final CompilerEnvironment environment
     ) {
+        final List<String> argumentsList = ArgumentUtils.convertArgumentsToStringList(arguments, defaultArguments);
+
         CompilerRunnerUtil.outputCompilerMessagesAndHandleExitCode(messageCollector, collector, new Function<PrintStream, Integer>() {
             @Override
             public Integer fun(PrintStream stream) {
-                return execCompiler(compilerClassName, arguments, environment, stream, messageCollector);
+                return execCompiler(compilerClassName, ArrayUtil.toStringArray(argumentsList), environment, stream, messageCollector);
             }
         });
     }
 
     private static int execCompiler(
             String compilerClassName,
-            CommonCompilerArguments arguments,
+            String[] arguments,
             CompilerEnvironment environment,
             PrintStream out,
             MessageCollector messageCollector