Added "Additional command line parameters" to the Kotlin Compiler Settings tab.

.idea/artifacts/KotlinPlugin.xml

@@ -38,6 +38,7 @@
               <element id="module-output" name="util" />
               <element id="module-output" name="preloader" />
               <element id="file-copy" path="$PROJECT_DIR$/resources/manifest.properties" />
+              <element id="extracted-dir" path="$PROJECT_DIR$/dependencies/cli-parser-1.1.1.jar" path-in-jar="/" />
             </element>
           </element>
           <element id="library" level="project" name="kotlin-runtime" />

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2013 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.jet.compiler;
+
+import org.jetbrains.annotations.NotNull;
+
+public class AdditionalCompilerSettings {
+    private static final String DEFAULT_ADDITIONAL_ARGUMENTS = "-version -printArgs";
+
+    @NotNull
+    private String additionalArguments = DEFAULT_ADDITIONAL_ARGUMENTS;
+
+    @NotNull
+    public String getAdditionalArguments() {
+        return additionalArguments;
+    }
+
+    public void setAdditionalArguments(@NotNull String additionalArguments) {
+        this.additionalArguments = additionalArguments;
+    }
+
+}

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

@@ -24,6 +24,7 @@ public class SettingConstants {
     public static final String KOTLIN_COMMON_COMPILER_SETTINGS_SECTION = "KotlinCommonCompilerSettings";
     public static final String KOTLIN_TO_JS_COMPILER_SETTINGS_SECTION = "Kotlin2JsCompilerSettings";
     public static final String KOTLIN_TO_JVM_COMPILER_SETTINGS_SECTION = "Kotlin2JvmCompilerSettings";
+    public static final String KOTLIN_ADDITIONAL_COMPILER_SETTINGS_SECTION = "KotlinAdditionalCompilerSettings";
 
     public static final String KOTLIN_COMPILER_SETTINGS_FILE = "kotlinc.xml";
     public static final String KOTLIN_COMPILER_SETTINGS_PATH = PROJECT_CONFIG_DIR + "/" + KOTLIN_COMPILER_SETTINGS_FILE;

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

@@ -16,6 +16,7 @@
 
 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;
@@ -29,6 +30,7 @@ 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.cli.common.messages.MessageCollectorUtil;
+import org.jetbrains.jet.compiler.AdditionalCompilerSettings;
 
 import java.io.File;
 import java.io.PrintStream;
@@ -43,6 +45,7 @@ public class KotlinCompilerRunner {
     public static void runK2JvmCompiler(
             CommonCompilerArguments commonArguments,
             K2JVMCompilerArguments k2jvmArguments,
+            AdditionalCompilerSettings additionalSettings,
             MessageCollector messageCollector,
             CompilerEnvironment environment,
             File moduleFile,
@@ -51,12 +54,14 @@ public class KotlinCompilerRunner {
         K2JVMCompilerArguments arguments = mergeBeans(commonArguments, k2jvmArguments);
         setupK2JvmSettings(moduleFile, arguments);
 
-        runCompiler(K2JVM_COMPILER, arguments, DEFAULT_K2JVM_ARGUMENTS, messageCollector, collector, environment);
+        runCompiler(K2JVM_COMPILER, arguments, additionalSettings.getAdditionalArguments(),
+                    DEFAULT_K2JVM_ARGUMENTS, messageCollector, collector, environment);
     }
 
     public static void runK2JsCompiler(
             CommonCompilerArguments commonArguments,
             K2JSCompilerArguments k2jsArguments,
+            AdditionalCompilerSettings additionalSettings,
             MessageCollector messageCollector,
             CompilerEnvironment environment,
             OutputItemsCollector collector,
@@ -67,18 +72,21 @@ public class KotlinCompilerRunner {
         K2JSCompilerArguments arguments = mergeBeans(commonArguments, k2jsArguments);
         setupK2JsSettings(outputFile, sourceFiles, libraryFiles, arguments);
 
-        runCompiler(K2JS_COMPILER, arguments, DEFAULT_K2JS_ARGUMENTS, messageCollector, collector, environment);
+        runCompiler(K2JS_COMPILER, arguments, additionalSettings.getAdditionalArguments(),
+                    DEFAULT_K2JS_ARGUMENTS, messageCollector, collector, environment);
     }
 
     private static void runCompiler(
             final String compilerClassName,
             CommonCompilerArguments arguments,
+            String additionalArguments,
             CommonCompilerArguments defaultArguments,
             final MessageCollector messageCollector,
             OutputItemsCollector collector,
             final CompilerEnvironment environment
     ) {
         final List<String> argumentsList = ArgumentUtils.convertArgumentsToStringList(arguments, defaultArguments);
+        argumentsList.addAll(StringUtil.split(additionalArguments, " "));
 
         CompilerRunnerUtil.outputCompilerMessagesAndHandleExitCode(messageCollector, collector, new Function<PrintStream, Integer>() {
             @Override
@@ -125,8 +133,6 @@ public class KotlinCompilerRunner {
     private static void setupCommonSettings(CommonCompilerArguments settings) {
         settings.tags = true;
         settings.verbose = true;
-        settings.version = true;
-        settings.printArgs = true;
     }
 
     private static void setupK2JvmSettings(

idea/src/META-INF/plugin.xml

@@ -128,6 +128,9 @@
     <projectService serviceInterface="org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JsCompilerSettings"
                     serviceImplementation="org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JsCompilerSettings"/>
 
+    <projectService serviceInterface="org.jetbrains.jet.plugin.compiler.configuration.KotlinAdditionalCompilerSettings"
+                    serviceImplementation="org.jetbrains.jet.plugin.compiler.configuration.KotlinAdditionalCompilerSettings"/>
+
     <errorHandler implementation="org.jetbrains.jet.plugin.reporter.KotlinReportSubmitter"/>
 
     <internalFileTemplate name="Kotlin File"/>

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

@@ -35,9 +35,11 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.cli.common.arguments.CommonCompilerArguments;
 import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments;
 import org.jetbrains.jet.cli.common.messages.MessageCollector;
+import org.jetbrains.jet.compiler.AdditionalCompilerSettings;
 import org.jetbrains.jet.compiler.runner.*;
 import org.jetbrains.jet.plugin.JetFileType;
 import org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JvmCompilerSettings;
+import org.jetbrains.jet.plugin.compiler.configuration.KotlinAdditionalCompilerSettings;
 import org.jetbrains.jet.plugin.compiler.configuration.KotlinCommonCompilerSettings;
 import org.jetbrains.jet.plugin.framework.KotlinFrameworkDetector;
 
@@ -142,8 +144,10 @@ public class JetCompiler implements TranslatingCompiler {
     ) {
         CommonCompilerArguments commonArguments = KotlinCommonCompilerSettings.getInstance(project).getSettings();
         K2JVMCompilerArguments k2jvmArguments = Kotlin2JvmCompilerSettings.getInstance(project).getSettings();
+        AdditionalCompilerSettings additionalSettings = KotlinAdditionalCompilerSettings.getInstance(project).getSettings();
 
-        KotlinCompilerRunner.runK2JvmCompiler(commonArguments, k2jvmArguments, messageCollector, environment, scriptFile, outputItemsCollector);
+        KotlinCompilerRunner.runK2JvmCompiler(commonArguments, k2jvmArguments, additionalSettings,
+                                              messageCollector, environment, scriptFile, outputItemsCollector);
     }
 
     public static File tryToWriteScriptFile(

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

@@ -19,6 +19,7 @@ package org.jetbrains.jet.plugin.compiler;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.compiler.*;
 import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ModuleOrderEntry;
 import com.intellij.openapi.roots.ModuleRootManager;
 import com.intellij.openapi.roots.OrderEntry;
@@ -33,11 +34,13 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.cli.common.arguments.CommonCompilerArguments;
 import org.jetbrains.jet.cli.common.arguments.K2JSCompilerArguments;
 import org.jetbrains.jet.cli.common.messages.MessageCollector;
+import org.jetbrains.jet.compiler.AdditionalCompilerSettings;
 import org.jetbrains.jet.compiler.runner.CompilerEnvironment;
 import org.jetbrains.jet.compiler.runner.KotlinCompilerRunner;
 import org.jetbrains.jet.compiler.runner.OutputItemsCollectorImpl;
 import org.jetbrains.jet.plugin.JetFileType;
 import org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JsCompilerSettings;
+import org.jetbrains.jet.plugin.compiler.configuration.KotlinAdditionalCompilerSettings;
 import org.jetbrains.jet.plugin.compiler.configuration.KotlinCommonCompilerSettings;
 import org.jetbrains.jet.plugin.framework.KotlinFrameworkDetector;
 
@@ -97,10 +100,12 @@ public final class K2JSCompiler implements TranslatingCompiler {
 
         OutputItemsCollectorImpl outputItemsCollector = new OutputItemsCollectorImpl();
 
-        CommonCompilerArguments commonArguments = KotlinCommonCompilerSettings.getInstance(module.getProject()).getSettings();
+        Project project = module.getProject();
-        K2JSCompilerArguments k2jsArguments = Kotlin2JsCompilerSettings.getInstance(module.getProject()).getSettings();
+        CommonCompilerArguments commonArguments = KotlinCommonCompilerSettings.getInstance(project).getSettings();
+        K2JSCompilerArguments k2jsArguments = Kotlin2JsCompilerSettings.getInstance(project).getSettings();
+        AdditionalCompilerSettings additionalSettings = KotlinAdditionalCompilerSettings.getInstance(project).getSettings();
 
-        KotlinCompilerRunner.runK2JsCompiler(commonArguments, k2jsArguments, messageCollector, environment,
+        KotlinCompilerRunner.runK2JsCompiler(commonArguments, k2jsArguments, additionalSettings, messageCollector, environment,
                                              outputItemsCollector, srcFiles, libraryFiles, outFile);
 
         if (!ApplicationManager.getApplication().isUnitTestMode()) {

idea/src/org/jetbrains/jet/plugin/compiler/configuration/BaseKotlinCompilerSettings.java

@@ -22,9 +22,8 @@ import com.intellij.util.xmlb.XmlSerializer;
 import org.jdom.Element;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.cli.common.arguments.CommonCompilerArguments;
 
-public abstract class BaseKotlinCompilerSettings<T extends CommonCompilerArguments> implements PersistentStateComponent<Element> {
+public abstract class BaseKotlinCompilerSettings<T> implements PersistentStateComponent<Element> {
 
     private static final SkipDefaultValuesSerializationFilters SKIP_DEFAULT_VALUES = new SkipDefaultValuesSerializationFilters();
 

idea/src/org/jetbrains/jet/plugin/compiler/configuration/KotlinAdditionalCompilerSettings.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010-2013 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.jet.plugin.compiler.configuration;
+
+import com.intellij.openapi.components.*;
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.compiler.AdditionalCompilerSettings;
+
+import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_ADDITIONAL_COMPILER_SETTINGS_SECTION;
+import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMPILER_SETTINGS_PATH;
+
+@State(
+    name = KOTLIN_ADDITIONAL_COMPILER_SETTINGS_SECTION,
+    storages = {
+        @Storage(file = StoragePathMacros.PROJECT_FILE),
+        @Storage(file = KOTLIN_COMPILER_SETTINGS_PATH, scheme = StorageScheme.DIRECTORY_BASED)
+    }
+)
+public class KotlinAdditionalCompilerSettings extends BaseKotlinCompilerSettings<AdditionalCompilerSettings> {
+
+    @NotNull
+    @Override
+    protected AdditionalCompilerSettings createSettings() {
+        return new AdditionalCompilerSettings();
+    }
+
+    public static KotlinAdditionalCompilerSettings getInstance(Project project) {
+        return ServiceManager.getService(project, KotlinAdditionalCompilerSettings.class);
+    }
+}

idea/src/org/jetbrains/jet/plugin/compiler/configuration/KotlinCompilerConfigurableTab.form

@@ -1,27 +1,53 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <form xmlns="http://www.intellij.com/uidesigner/form/" version="1" bind-to-class="org.jetbrains.jet.plugin.compiler.configuration.KotlinCompilerConfigurableTab">
-  <grid id="27dc6" binding="contentPane" layout-manager="GridLayoutManager" row-count="2" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+  <grid id="27dc6" binding="contentPane" layout-manager="GridLayoutManager" row-count="2" column-count="1" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
     <margin top="0" left="0" bottom="0" right="0"/>
     <constraints>
-      <xy x="20" y="20" width="332" height="102"/>
+      <xy x="20" y="20" width="437" height="221"/>
     </constraints>
     <properties/>
     <border type="none"/>
     <children>
       <vspacer id="c5558">
         <constraints>
-          <grid row="1" column="0" row-span="1" col-span="2" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
+          <grid row="1" column="0" row-span="1" col-span="1" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
         </constraints>
       </vspacer>
-      <component id="f842a" class="javax.swing.JCheckBox" binding="generateNoWarningsCheckBox" default-binding="true">
+      <grid id="27e96" layout-manager="GridLayoutManager" row-count="2" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+        <margin top="0" left="0" bottom="0" right="0"/>
         <constraints>
-          <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+          <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="3" hsize-policy="3" anchor="1" fill="1" indent="0" use-parent-layout="false"/>
         </constraints>
-        <properties>
+        <properties/>
-          <selected value="false"/>
+        <border type="none"/>
-          <text value="Generate no warnings"/>
+        <children>
-        </properties>
+          <component id="3b8d3" class="javax.swing.JCheckBox" binding="generateNoWarningsCheckBox" default-binding="true">
-      </component>
+            <constraints>
+              <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+            </constraints>
+            <properties>
+              <selected value="false"/>
+              <text value="Generate no warnings"/>
+            </properties>
+          </component>
+          <component id="ba279" class="javax.swing.JLabel" binding="additionalArgsLabel">
+            <constraints>
+              <grid row="1" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+            </constraints>
+            <properties>
+              <text value="Additional command line parameters:"/>
+            </properties>
+          </component>
+          <component id="7a827" class="com.intellij.ui.RawCommandLineEditor" binding="additionalArgsOptionsField">
+            <constraints>
+              <grid row="1" column="1" row-span="1" col-span="1" vsize-policy="0" hsize-policy="6" anchor="8" fill="1" indent="0" use-parent-layout="false">
+                <preferred-size width="150" height="-1"/>
+              </grid>
+            </constraints>
+            <properties/>
+          </component>
+        </children>
+      </grid>
     </children>
   </grid>
 </form>

idea/src/org/jetbrains/jet/plugin/compiler/configuration/KotlinCompilerConfigurableTab.java

@@ -21,10 +21,12 @@ import com.intellij.openapi.options.Configurable;
 import com.intellij.openapi.options.ConfigurableEP;
 import com.intellij.openapi.options.ConfigurationException;
 import com.intellij.openapi.options.SearchableConfigurable;
+import com.intellij.ui.RawCommandLineEditor;
 import org.jetbrains.annotations.Nls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.cli.common.arguments.CommonCompilerArguments;
+import org.jetbrains.jet.compiler.AdditionalCompilerSettings;
 
 import javax.swing.*;
 
@@ -32,13 +34,20 @@ import static org.jetbrains.jet.cli.common.arguments.CommonArgumentConstants.SUP
 
 public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Configurable.NoScroll{
     private final CommonCompilerArguments commonCompilerSettings;
+    private final AdditionalCompilerSettings additionalCompilerSettings;
     private final ConfigurableEP extPoint;
     private JPanel contentPane;
     private JCheckBox generateNoWarningsCheckBox;
+    private RawCommandLineEditor additionalArgsOptionsField;
+    private JLabel additionalArgsLabel;
 
     public KotlinCompilerConfigurableTab(ConfigurableEP ep) {
         this.extPoint = ep;
         this.commonCompilerSettings = KotlinCommonCompilerSettings.getInstance(ep.getProject()).getSettings();
+        this.additionalCompilerSettings = KotlinAdditionalCompilerSettings.getInstance(ep.getProject()).getSettings();
+
+        additionalArgsOptionsField.attachLabel(additionalArgsLabel);
+        additionalArgsOptionsField.setDialogCaption(null);
     }
 
     @NotNull
@@ -61,17 +70,20 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
 
     @Override
     public boolean isModified() {
-        return ComparingUtils.isModified(generateNoWarningsCheckBox, isGenerateNoWarnings());
+        return ComparingUtils.isModified(generateNoWarningsCheckBox, isGenerateNoWarnings()) ||
+               ComparingUtils.isModified(additionalArgsOptionsField, additionalCompilerSettings.getAdditionalArguments());
     }
 
     @Override
     public void apply() throws ConfigurationException {
         setGenerateNoWarnings(generateNoWarningsCheckBox.isSelected());
+        additionalCompilerSettings.setAdditionalArguments(additionalArgsOptionsField.getText());
     }
 
     @Override
     public void reset() {
         generateNoWarningsCheckBox.setSelected(isGenerateNoWarnings());
+        additionalArgsOptionsField.setText(additionalCompilerSettings.getAdditionalArguments());
     }
 
     @Override
@@ -95,6 +107,6 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
     }
 
     private void setGenerateNoWarnings(boolean selected) {
-        commonCompilerSettings.suppress = selected ? SUPPRESS_WARNINGS : "";
+        commonCompilerSettings.suppress = selected ? SUPPRESS_WARNINGS : null;
     }
 }

jps-plugin/src/org/jetbrains/jet/jps/JpsKotlinCompilerSettings.java

@@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull;
 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.compiler.AdditionalCompilerSettings;
 import org.jetbrains.jps.model.JpsElementChildRole;
 import org.jetbrains.jps.model.JpsProject;
 import org.jetbrains.jps.model.ex.JpsElementBase;
@@ -34,6 +35,8 @@ public class JpsKotlinCompilerSettings extends JpsElementBase<JpsKotlinCompilerS
     public K2JVMCompilerArguments k2JvmCompilerSettings = new K2JVMCompilerArguments();
     @NotNull
     public K2JSCompilerArguments k2JsCompilerSettings = new K2JSCompilerArguments();
+    @NotNull
+    public AdditionalCompilerSettings additionalCompilerSettings = new AdditionalCompilerSettings();
 
     @NotNull
     @Override
@@ -42,6 +45,7 @@ public class JpsKotlinCompilerSettings extends JpsElementBase<JpsKotlinCompilerS
         copy.commonCompilerSettings = this.commonCompilerSettings;
         copy.k2JvmCompilerSettings = this.k2JvmCompilerSettings;
         copy.k2JsCompilerSettings = this.k2JsCompilerSettings;
+        copy.additionalCompilerSettings = this.additionalCompilerSettings;
         return copy;
     }
 
@@ -95,4 +99,13 @@ public class JpsKotlinCompilerSettings extends JpsElementBase<JpsKotlinCompilerS
     public static void setK2JsSettings(@NotNull JpsProject project, @NotNull K2JSCompilerArguments k2JsCompilerSettings) {
         getOrCreateSettings(project).k2JsCompilerSettings = k2JsCompilerSettings;
     }
+
+    @NotNull
+    public static AdditionalCompilerSettings getAdditionalSettings(@NotNull JpsProject project) {
+        return getSettings(project).additionalCompilerSettings;
+    }
+
+    public static void setAdditionalSettings(@NotNull JpsProject project, @NotNull AdditionalCompilerSettings additionalCompilerSettings) {
+        getOrCreateSettings(project).additionalCompilerSettings = additionalCompilerSettings;
+    }
 }

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

@@ -27,6 +27,7 @@ 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.AdditionalCompilerSettings;
 import org.jetbrains.jet.compiler.runner.CompilerEnvironment;
 import org.jetbrains.jet.compiler.runner.CompilerRunnerConstants;
 import org.jetbrains.jet.compiler.runner.OutputItemsCollectorImpl;
@@ -117,6 +118,7 @@ public class KotlinBuilder extends ModuleLevelBuilder {
 
         JpsProject project = representativeTarget.getModule().getProject();
         CommonCompilerArguments commonSettings = JpsKotlinCompilerSettings.getCommonSettings(project);
+        AdditionalCompilerSettings additionalSettings = JpsKotlinCompilerSettings.getAdditionalSettings(project);
 
         if (JpsUtils.isJsKotlinModule(representativeTarget)) {
             if (chunk.getModules().size() > 1) {
@@ -141,7 +143,8 @@ public class KotlinBuilder extends ModuleLevelBuilder {
             List<String> libraryFiles = JpsJsModuleUtils.getLibraryFilesAndDependencies(representativeTarget);
             K2JSCompilerArguments k2JsSettings = JpsKotlinCompilerSettings.getK2JsSettings(project);
 
-            runK2JsCompiler(commonSettings, k2JsSettings, messageCollector, environment, outputItemCollector, sourceFiles, libraryFiles, outputFile);
+            runK2JsCompiler(commonSettings, k2JsSettings, additionalSettings, messageCollector, environment,
+                            outputItemCollector, sourceFiles, libraryFiles, outputFile);
         }
         else {
             if (chunk.getModules().size() > 1) {
@@ -160,7 +163,8 @@ public class KotlinBuilder extends ModuleLevelBuilder {
 
             K2JVMCompilerArguments k2JvmSettings = JpsKotlinCompilerSettings.getK2JvmSettings(project);
 
-            runK2JvmCompiler(commonSettings, k2JvmSettings, messageCollector, environment, moduleFile, outputItemCollector);
+            runK2JvmCompiler(commonSettings, k2JvmSettings, additionalSettings, messageCollector, environment,
+                             moduleFile, outputItemCollector);
         }
 
         // If there's only one target, this map is empty: get() always returns null, and the representativeTarget will be used below

jps-plugin/src/org/jetbrains/jet/jps/model/KotlinAdditionalCompilerSettingsSerializer.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2010-2013 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.jet.jps.model;
+
+import com.intellij.util.xmlb.XmlSerializer;
+import org.jdom.Element;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.compiler.AdditionalCompilerSettings;
+import org.jetbrains.jet.jps.JpsKotlinCompilerSettings;
+import org.jetbrains.jps.model.JpsProject;
+import org.jetbrains.jps.model.serialization.JpsProjectExtensionSerializer;
+
+import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_ADDITIONAL_COMPILER_SETTINGS_SECTION;
+import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMPILER_SETTINGS_FILE;
+
+class KotlinAdditionalCompilerSettingsSerializer extends JpsProjectExtensionSerializer {
+    KotlinAdditionalCompilerSettingsSerializer() {
+        super(KOTLIN_COMPILER_SETTINGS_FILE, KOTLIN_ADDITIONAL_COMPILER_SETTINGS_SECTION);
+    }
+
+    @Override
+    public void loadExtension(@NotNull JpsProject project, @NotNull Element componentTag) {
+        AdditionalCompilerSettings settings = XmlSerializer.deserialize(componentTag, AdditionalCompilerSettings.class);
+        if (settings == null) {
+            settings = new AdditionalCompilerSettings();
+        }
+
+        JpsKotlinCompilerSettings.setAdditionalSettings(project, settings);
+    }
+
+    @Override
+    public void saveExtension(@NotNull JpsProject project, @NotNull Element componentTag) {
+    }
+}

jps-plugin/src/org/jetbrains/jet/jps/model/KotlinModelSerializerService.java

@@ -29,6 +29,7 @@ public class KotlinModelSerializerService extends JpsModelSerializerExtension {
     public List<? extends JpsProjectExtensionSerializer> getProjectExtensionSerializers() {
         return Arrays.asList(new KotlinCommonCompilerSettingsSerializer(),
                              new Kotlin2JvmCompilerSettingsSerializer(),
-                             new Kotlin2JsCompilerSettingsSerializer());
+                             new Kotlin2JsCompilerSettingsSerializer(),
+                             new KotlinAdditionalCompilerSettingsSerializer());
     }
 }