Minor refactoring -- rename some classes and variables.

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

@@ -18,7 +18,7 @@ package org.jetbrains.jet.compiler;
 
 import org.jetbrains.annotations.NotNull;
 
-public class AdditionalCompilerSettings {
+public class CompilerSettings {
     private static final String DEFAULT_ADDITIONAL_ARGUMENTS = "-version -printArgs";
 
     @NotNull

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

@@ -21,10 +21,10 @@ import static com.intellij.openapi.components.StoragePathMacros.PROJECT_CONFIG_D
 public class SettingConstants {
     private SettingConstants() {}
 
-    public static final String KOTLIN_COMMON_COMPILER_SETTINGS_SECTION = "KotlinCommonCompilerSettings";
+    public static final String KOTLIN_COMMON_COMPILER_ARGUMENTS_SECTION = "KotlinCommonCompilerArguments";
-    public static final String KOTLIN_TO_JS_COMPILER_SETTINGS_SECTION = "Kotlin2JsCompilerSettings";
+    public static final String KOTLIN_TO_JS_COMPILER_ARGUMENTS_SECTION = "Kotlin2JsCompilerArguments";
-    public static final String KOTLIN_TO_JVM_COMPILER_SETTINGS_SECTION = "Kotlin2JvmCompilerSettings";
+    public static final String KOTLIN_TO_JVM_COMPILER_ARGUMENTS_SECTION = "Kotlin2JvmCompilerArguments";
-    public static final String KOTLIN_ADDITIONAL_COMPILER_SETTINGS_SECTION = "KotlinAdditionalCompilerSettings";
+    public static final String KOTLIN_COMPILER_SETTINGS_SECTION = "KotlinCompilerSettings";
 
     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

@@ -30,7 +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 org.jetbrains.jet.compiler.CompilerSettings;
 
 import java.io.File;
 import java.io.PrintStream;
@@ -45,23 +45,23 @@ public class KotlinCompilerRunner {
     public static void runK2JvmCompiler(
             CommonCompilerArguments commonArguments,
             K2JVMCompilerArguments k2jvmArguments,
-            AdditionalCompilerSettings additionalSettings,
+            CompilerSettings compilerSettings,
             MessageCollector messageCollector,
             CompilerEnvironment environment,
             File moduleFile,
             OutputItemsCollector collector
     ) {
         K2JVMCompilerArguments arguments = mergeBeans(commonArguments, k2jvmArguments);
-        setupK2JvmSettings(moduleFile, arguments);
+        setupK2JvmArguments(moduleFile, arguments);
 
-        runCompiler(K2JVM_COMPILER, arguments, additionalSettings.getAdditionalArguments(),
+        runCompiler(K2JVM_COMPILER, arguments, compilerSettings.getAdditionalArguments(),
                     DEFAULT_K2JVM_ARGUMENTS, messageCollector, collector, environment);
     }
 
     public static void runK2JsCompiler(
             CommonCompilerArguments commonArguments,
             K2JSCompilerArguments k2jsArguments,
-            AdditionalCompilerSettings additionalSettings,
+            CompilerSettings compilerSettings,
             MessageCollector messageCollector,
             CompilerEnvironment environment,
             OutputItemsCollector collector,
@@ -70,9 +70,9 @@ public class KotlinCompilerRunner {
             File outputFile
     ) {
         K2JSCompilerArguments arguments = mergeBeans(commonArguments, k2jsArguments);
-        setupK2JsSettings(outputFile, sourceFiles, libraryFiles, arguments);
+        setupK2JsArguments(outputFile, sourceFiles, libraryFiles, arguments);
 
-        runCompiler(K2JS_COMPILER, arguments, additionalSettings.getAdditionalArguments(),
+        runCompiler(K2JS_COMPILER, arguments, compilerSettings.getAdditionalArguments(),
                     DEFAULT_K2JS_ARGUMENTS, messageCollector, collector, environment);
     }
 
@@ -135,7 +135,7 @@ public class KotlinCompilerRunner {
         settings.verbose = true;
     }
 
-    private static void setupK2JvmSettings(
+    private static void setupK2JvmArguments(
             File moduleFile,
             K2JVMCompilerArguments settings
     ) {
@@ -149,7 +149,7 @@ public class KotlinCompilerRunner {
         settings.noJdk = true;
     }
 
-    private static void setupK2JsSettings(
+    private static void setupK2JsArguments(
             File outputFile,
             List<File> sourceFiles,
             List<String> libraryFiles,

idea/src/META-INF/plugin.xml

@@ -119,17 +119,17 @@
     <projectService serviceInterface="org.jetbrains.jet.plugin.configuration.ModuleTypeCacheManager"
                     serviceImplementation="org.jetbrains.jet.plugin.configuration.ModuleTypeCacheManager"/>
 
-    <projectService serviceInterface="org.jetbrains.jet.plugin.compiler.configuration.KotlinCommonCompilerSettings"
+    <projectService serviceInterface="org.jetbrains.jet.plugin.compiler.configuration.KotlinCommonCompilerArgumentsHolder"
-                    serviceImplementation="org.jetbrains.jet.plugin.compiler.configuration.KotlinCommonCompilerSettings"/>
+                    serviceImplementation="org.jetbrains.jet.plugin.compiler.configuration.KotlinCommonCompilerArgumentsHolder"/>
 
-    <projectService serviceInterface="org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JvmCompilerSettings"
+    <projectService serviceInterface="org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JvmCompilerArgumentsHolder"
-                    serviceImplementation="org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JvmCompilerSettings"/>
+                    serviceImplementation="org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JvmCompilerArgumentsHolder"/>
 
-    <projectService serviceInterface="org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JsCompilerSettings"
+    <projectService serviceInterface="org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JsCompilerArgumentsHolder"
-                    serviceImplementation="org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JsCompilerSettings"/>
+                    serviceImplementation="org.jetbrains.jet.plugin.compiler.configuration.Kotlin2JsCompilerArgumentsHolder"/>
 
-    <projectService serviceInterface="org.jetbrains.jet.plugin.compiler.configuration.KotlinAdditionalCompilerSettings"
+    <projectService serviceInterface="org.jetbrains.jet.plugin.compiler.configuration.KotlinCompilerSettings"
-                    serviceImplementation="org.jetbrains.jet.plugin.compiler.configuration.KotlinAdditionalCompilerSettings"/>
+                    serviceImplementation="org.jetbrains.jet.plugin.compiler.configuration.KotlinCompilerSettings"/>
 
     <errorHandler implementation="org.jetbrains.jet.plugin.reporter.KotlinReportSubmitter"/>
 

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

@@ -35,12 +35,12 @@ 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.CompilerSettings;
 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.Kotlin2JvmCompilerArgumentsHolder;
-import org.jetbrains.jet.plugin.compiler.configuration.KotlinAdditionalCompilerSettings;
+import org.jetbrains.jet.plugin.compiler.configuration.KotlinCommonCompilerArgumentsHolder;
-import org.jetbrains.jet.plugin.compiler.configuration.KotlinCommonCompilerSettings;
+import org.jetbrains.jet.plugin.compiler.configuration.KotlinCompilerSettings;
 import org.jetbrains.jet.plugin.framework.KotlinFrameworkDetector;
 
 import java.io.File;
@@ -142,11 +142,11 @@ public class JetCompiler implements TranslatingCompiler {
             File scriptFile,
             OutputItemsCollector outputItemsCollector
     ) {
-        CommonCompilerArguments commonArguments = KotlinCommonCompilerSettings.getInstance(project).getSettings();
+        CommonCompilerArguments commonArguments = KotlinCommonCompilerArgumentsHolder.getInstance(project).getSettings();
-        K2JVMCompilerArguments k2jvmArguments = Kotlin2JvmCompilerSettings.getInstance(project).getSettings();
+        K2JVMCompilerArguments k2jvmArguments = Kotlin2JvmCompilerArgumentsHolder.getInstance(project).getSettings();
-        AdditionalCompilerSettings additionalSettings = KotlinAdditionalCompilerSettings.getInstance(project).getSettings();
+        CompilerSettings compilerSettings = KotlinCompilerSettings.getInstance(project).getSettings();
 
-        KotlinCompilerRunner.runK2JvmCompiler(commonArguments, k2jvmArguments, additionalSettings,
+        KotlinCompilerRunner.runK2JvmCompiler(commonArguments, k2jvmArguments, compilerSettings,
                                               messageCollector, environment, scriptFile, outputItemsCollector);
     }
 

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

@@ -34,14 +34,14 @@ 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.CompilerSettings;
 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.Kotlin2JsCompilerArgumentsHolder;
-import org.jetbrains.jet.plugin.compiler.configuration.KotlinAdditionalCompilerSettings;
+import org.jetbrains.jet.plugin.compiler.configuration.KotlinCommonCompilerArgumentsHolder;
-import org.jetbrains.jet.plugin.compiler.configuration.KotlinCommonCompilerSettings;
+import org.jetbrains.jet.plugin.compiler.configuration.KotlinCompilerSettings;
 import org.jetbrains.jet.plugin.framework.KotlinFrameworkDetector;
 
 import java.io.File;
@@ -101,11 +101,11 @@ public final class K2JSCompiler implements TranslatingCompiler {
         OutputItemsCollectorImpl outputItemsCollector = new OutputItemsCollectorImpl();
 
         Project project = module.getProject();
-        CommonCompilerArguments commonArguments = KotlinCommonCompilerSettings.getInstance(project).getSettings();
+        CommonCompilerArguments commonArguments = KotlinCommonCompilerArgumentsHolder.getInstance(project).getSettings();
-        K2JSCompilerArguments k2jsArguments = Kotlin2JsCompilerSettings.getInstance(project).getSettings();
+        K2JSCompilerArguments k2jsArguments = Kotlin2JsCompilerArgumentsHolder.getInstance(project).getSettings();
-        AdditionalCompilerSettings additionalSettings = KotlinAdditionalCompilerSettings.getInstance(project).getSettings();
+        CompilerSettings compilerSettings = KotlinCompilerSettings.getInstance(project).getSettings();
 
-        KotlinCompilerRunner.runK2JsCompiler(commonArguments, k2jsArguments, additionalSettings, messageCollector, environment,
+        KotlinCompilerRunner.runK2JsCompiler(commonArguments, k2jsArguments, compilerSettings, messageCollector, environment,
                                              outputItemsCollector, srcFiles, libraryFiles, outFile);
 
         if (!ApplicationManager.getApplication().isUnitTestMode()) {

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

@@ -22,16 +22,16 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.cli.common.arguments.K2JSCompilerArguments;
 
 import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMPILER_SETTINGS_PATH;
-import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_TO_JS_COMPILER_SETTINGS_SECTION;
+import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_TO_JS_COMPILER_ARGUMENTS_SECTION;
 
 @State(
-    name = KOTLIN_TO_JS_COMPILER_SETTINGS_SECTION,
+    name = KOTLIN_TO_JS_COMPILER_ARGUMENTS_SECTION,
     storages = {
         @Storage(file = StoragePathMacros.PROJECT_FILE),
         @Storage(file = KOTLIN_COMPILER_SETTINGS_PATH, scheme = StorageScheme.DIRECTORY_BASED)
     }
 )
-public class Kotlin2JsCompilerSettings extends BaseKotlinCompilerSettings<K2JSCompilerArguments> {
+public class Kotlin2JsCompilerArgumentsHolder extends BaseKotlinCompilerSettings<K2JSCompilerArguments> {
 
     @NotNull
     @Override
@@ -39,7 +39,7 @@ public class Kotlin2JsCompilerSettings extends BaseKotlinCompilerSettings<K2JSCo
         return new K2JSCompilerArguments();
     }
 
-    public static Kotlin2JsCompilerSettings getInstance(Project project) {
+    public static Kotlin2JsCompilerArgumentsHolder getInstance(Project project) {
-        return ServiceManager.getService(project, Kotlin2JsCompilerSettings.class);
+        return ServiceManager.getService(project, Kotlin2JsCompilerArgumentsHolder.class);
     }
 }

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

@@ -22,16 +22,16 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments;
 
 import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMPILER_SETTINGS_PATH;
-import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_TO_JVM_COMPILER_SETTINGS_SECTION;
+import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_TO_JVM_COMPILER_ARGUMENTS_SECTION;
 
 @State(
-    name = KOTLIN_TO_JVM_COMPILER_SETTINGS_SECTION,
+    name = KOTLIN_TO_JVM_COMPILER_ARGUMENTS_SECTION,
     storages = {
         @Storage(file = StoragePathMacros.PROJECT_FILE),
         @Storage(file = KOTLIN_COMPILER_SETTINGS_PATH, scheme = StorageScheme.DIRECTORY_BASED)
     }
 )
-public class Kotlin2JvmCompilerSettings extends BaseKotlinCompilerSettings<K2JVMCompilerArguments> {
+public class Kotlin2JvmCompilerArgumentsHolder extends BaseKotlinCompilerSettings<K2JVMCompilerArguments> {
 
     @NotNull
     @Override
@@ -39,7 +39,7 @@ public class Kotlin2JvmCompilerSettings extends BaseKotlinCompilerSettings<K2JVM
         return new K2JVMCompilerArguments();
     }
 
-    public static Kotlin2JvmCompilerSettings getInstance(Project project) {
+    public static Kotlin2JvmCompilerArgumentsHolder getInstance(Project project) {
-        return ServiceManager.getService(project, Kotlin2JvmCompilerSettings.class);
+        return ServiceManager.getService(project, Kotlin2JvmCompilerArgumentsHolder.class);
     }
 }

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

@@ -21,17 +21,17 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.cli.common.arguments.CommonCompilerArguments;
 
-import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMMON_COMPILER_SETTINGS_SECTION;
+import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMMON_COMPILER_ARGUMENTS_SECTION;
 import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMPILER_SETTINGS_PATH;
 
 @State(
-    name = KOTLIN_COMMON_COMPILER_SETTINGS_SECTION,
+    name = KOTLIN_COMMON_COMPILER_ARGUMENTS_SECTION,
     storages = {
         @Storage(file = StoragePathMacros.PROJECT_FILE),
         @Storage(file = KOTLIN_COMPILER_SETTINGS_PATH, scheme = StorageScheme.DIRECTORY_BASED)
     }
 )
-public class KotlinCommonCompilerSettings extends BaseKotlinCompilerSettings<CommonCompilerArguments> {
+public class KotlinCommonCompilerArgumentsHolder extends BaseKotlinCompilerSettings<CommonCompilerArguments> {
 
     @NotNull
     @Override
@@ -39,7 +39,7 @@ public class KotlinCommonCompilerSettings extends BaseKotlinCompilerSettings<Com
         return new CommonCompilerArguments.DummyImpl();
     }
 
-    public static KotlinCommonCompilerSettings getInstance(Project project) {
+    public static KotlinCommonCompilerArgumentsHolder getInstance(Project project) {
-        return ServiceManager.getService(project, KotlinCommonCompilerSettings.class);
+        return ServiceManager.getService(project, KotlinCommonCompilerArgumentsHolder.class);
     }
 }

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

@@ -31,7 +31,7 @@ import org.jetbrains.annotations.NotNull;
 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.compiler.AdditionalCompilerSettings;
+import org.jetbrains.jet.compiler.CompilerSettings;
 import org.jetbrains.jet.plugin.JetBundle;
 
 import javax.swing.*;
@@ -39,9 +39,9 @@ import javax.swing.*;
 import static org.jetbrains.jet.cli.common.arguments.CommonArgumentConstants.SUPPRESS_WARNINGS;
 
 public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Configurable.NoScroll{
-    private final CommonCompilerArguments commonCompilerSettings;
+    private final CommonCompilerArguments commonCompilerArguments;
-    private final K2JSCompilerArguments k2jsCompilerSettings;
+    private final K2JSCompilerArguments k2jsCompilerArguments;
-    private final AdditionalCompilerSettings additionalCompilerSettings;
+    private final CompilerSettings compilerSettings;
     private final ConfigurableEP extPoint;
     private JPanel contentPane;
     private JCheckBox generateNoWarningsCheckBox;
@@ -55,9 +55,9 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
 
     public KotlinCompilerConfigurableTab(ConfigurableEP ep) {
         this.extPoint = ep;
-        this.commonCompilerSettings = KotlinCommonCompilerSettings.getInstance(ep.getProject()).getSettings();
+        this.commonCompilerArguments = KotlinCommonCompilerArgumentsHolder.getInstance(ep.getProject()).getSettings();
-        this.k2jsCompilerSettings = Kotlin2JsCompilerSettings.getInstance(ep.getProject()).getSettings();
+        this.k2jsCompilerArguments = Kotlin2JsCompilerArgumentsHolder.getInstance(ep.getProject()).getSettings();
-        this.additionalCompilerSettings = KotlinAdditionalCompilerSettings.getInstance(ep.getProject()).getSettings();
+        this.compilerSettings = KotlinCompilerSettings.getInstance(ep.getProject()).getSettings();
 
         additionalArgsOptionsField.attachLabel(additionalArgsLabel);
         additionalArgsOptionsField.setDialogCaption(JetBundle.message("kotlin.compiler.option.additional.command.line.parameters.dialog.title"));
@@ -89,28 +89,28 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
     @Override
     public boolean isModified() {
         return ComparingUtils.isModified(generateNoWarningsCheckBox, isGenerateNoWarnings()) ||
-               ComparingUtils.isModified(additionalArgsOptionsField, additionalCompilerSettings.getAdditionalArguments()) ||
+               ComparingUtils.isModified(additionalArgsOptionsField, compilerSettings.getAdditionalArguments()) ||
-               ComparingUtils.isModified(generateSourceMapsCheckBox, k2jsCompilerSettings.sourcemap) ||
+               ComparingUtils.isModified(generateSourceMapsCheckBox, k2jsCompilerArguments.sourcemap) ||
-               isModified(outputPrefixFile, k2jsCompilerSettings.outputPrefix) ||
+               isModified(outputPrefixFile, k2jsCompilerArguments.outputPrefix) ||
-               isModified(outputPostfixFile, k2jsCompilerSettings.outputPostfix);
+               isModified(outputPostfixFile, k2jsCompilerArguments.outputPostfix);
     }
 
     @Override
     public void apply() throws ConfigurationException {
         setGenerateNoWarnings(generateNoWarningsCheckBox.isSelected());
-        additionalCompilerSettings.setAdditionalArguments(additionalArgsOptionsField.getText());
+        compilerSettings.setAdditionalArguments(additionalArgsOptionsField.getText());
-        k2jsCompilerSettings.sourcemap = generateSourceMapsCheckBox.isSelected();
+        k2jsCompilerArguments.sourcemap = generateSourceMapsCheckBox.isSelected();
-        k2jsCompilerSettings.outputPrefix = StringUtil.nullize(outputPrefixFile.getText(), true);
+        k2jsCompilerArguments.outputPrefix = StringUtil.nullize(outputPrefixFile.getText(), true);
-        k2jsCompilerSettings.outputPostfix = StringUtil.nullize(outputPostfixFile.getText(), true);
+        k2jsCompilerArguments.outputPostfix = StringUtil.nullize(outputPostfixFile.getText(), true);
     }
 
     @Override
     public void reset() {
         generateNoWarningsCheckBox.setSelected(isGenerateNoWarnings());
-        additionalArgsOptionsField.setText(additionalCompilerSettings.getAdditionalArguments());
+        additionalArgsOptionsField.setText(compilerSettings.getAdditionalArguments());
-        generateSourceMapsCheckBox.setSelected(k2jsCompilerSettings.sourcemap);
+        generateSourceMapsCheckBox.setSelected(k2jsCompilerArguments.sourcemap);
-        outputPrefixFile.setText(k2jsCompilerSettings.outputPrefix);
+        outputPrefixFile.setText(k2jsCompilerArguments.outputPrefix);
-        outputPostfixFile.setText(k2jsCompilerSettings.outputPostfix);
+        outputPostfixFile.setText(k2jsCompilerArguments.outputPostfix);
     }
 
     @Override
@@ -130,11 +130,11 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
     }
 
     private boolean isGenerateNoWarnings() {
-        return commonCompilerSettings.suppressAllWarnings();
+        return commonCompilerArguments.suppressAllWarnings();
     }
 
     private void setGenerateNoWarnings(boolean selected) {
-        commonCompilerSettings.suppress = selected ? SUPPRESS_WARNINGS : null;
+        commonCompilerArguments.suppress = selected ? SUPPRESS_WARNINGS : null;
     }
 
     private static void setupFileChooser(

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

@@ -19,27 +19,27 @@ 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 org.jetbrains.jet.compiler.CompilerSettings;
 
-import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_ADDITIONAL_COMPILER_SETTINGS_SECTION;
+import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMPILER_SETTINGS_SECTION;
 import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMPILER_SETTINGS_PATH;
 
 @State(
-    name = KOTLIN_ADDITIONAL_COMPILER_SETTINGS_SECTION,
+    name = KOTLIN_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> {
+public class KotlinCompilerSettings extends BaseKotlinCompilerSettings<CompilerSettings> {
 
     @NotNull
     @Override
-    protected AdditionalCompilerSettings createSettings() {
+    protected CompilerSettings createSettings() {
-        return new AdditionalCompilerSettings();
+        return new CompilerSettings();
     }
 
-    public static KotlinAdditionalCompilerSettings getInstance(Project project) {
+    public static KotlinCompilerSettings getInstance(Project project) {
-        return ServiceManager.getService(project, KotlinAdditionalCompilerSettings.class);
+        return ServiceManager.getService(project, KotlinCompilerSettings.class);
     }
 }

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

@@ -20,7 +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.jet.compiler.CompilerSettings;
 import org.jetbrains.jps.model.JpsElementChildRole;
 import org.jetbrains.jps.model.JpsProject;
 import org.jetbrains.jps.model.ex.JpsElementBase;
@@ -30,22 +30,22 @@ public class JpsKotlinCompilerSettings extends JpsElementBase<JpsKotlinCompilerS
     static final JpsElementChildRole<JpsKotlinCompilerSettings> ROLE = JpsElementChildRoleBase.create("Kotlin Compiler Settings");
 
     @NotNull
-    private CommonCompilerArguments commonCompilerSettings = new CommonCompilerArguments.DummyImpl();
+    private CommonCompilerArguments commonCompilerArguments = new CommonCompilerArguments.DummyImpl();
     @NotNull
-    private K2JVMCompilerArguments k2JvmCompilerSettings = new K2JVMCompilerArguments();
+    private K2JVMCompilerArguments k2JvmCompilerArguments = new K2JVMCompilerArguments();
     @NotNull
-    private K2JSCompilerArguments k2JsCompilerSettings = new K2JSCompilerArguments();
+    private K2JSCompilerArguments k2JsCompilerArguments = new K2JSCompilerArguments();
     @NotNull
-    private AdditionalCompilerSettings additionalCompilerSettings = new AdditionalCompilerSettings();
+    private CompilerSettings compilerSettings = new CompilerSettings();
 
     @NotNull
     @Override
     public JpsKotlinCompilerSettings createCopy() {
         JpsKotlinCompilerSettings copy = new JpsKotlinCompilerSettings();
-        copy.commonCompilerSettings = this.commonCompilerSettings;
+        copy.commonCompilerArguments = this.commonCompilerArguments;
-        copy.k2JvmCompilerSettings = this.k2JvmCompilerSettings;
+        copy.k2JvmCompilerArguments = this.k2JvmCompilerArguments;
-        copy.k2JsCompilerSettings = this.k2JsCompilerSettings;
+        copy.k2JsCompilerArguments = this.k2JsCompilerArguments;
-        copy.additionalCompilerSettings = this.additionalCompilerSettings;
+        copy.compilerSettings = this.compilerSettings;
         return copy;
     }
 
@@ -74,38 +74,38 @@ public class JpsKotlinCompilerSettings extends JpsElementBase<JpsKotlinCompilerS
     }
 
     @NotNull
-    public static CommonCompilerArguments getCommonSettings(@NotNull JpsProject project) {
+    public static CommonCompilerArguments getCommonCompilerArguments(@NotNull JpsProject project) {
-        return getSettings(project).commonCompilerSettings;
+        return getSettings(project).commonCompilerArguments;
     }
 
-    public static void setCommonSettings(@NotNull JpsProject project, @NotNull CommonCompilerArguments commonCompilerSettings) {
+    public static void setCommonCompilerArguments(@NotNull JpsProject project, @NotNull CommonCompilerArguments commonCompilerSettings) {
-        getOrCreateSettings(project).commonCompilerSettings = commonCompilerSettings;
+        getOrCreateSettings(project).commonCompilerArguments = commonCompilerSettings;
     }
 
     @NotNull
-    public static K2JVMCompilerArguments getK2JvmSettings(@NotNull JpsProject project) {
+    public static K2JVMCompilerArguments getK2JvmCompilerArguments(@NotNull JpsProject project) {
-        return getSettings(project).k2JvmCompilerSettings;
+        return getSettings(project).k2JvmCompilerArguments;
     }
 
-    public static void setK2JvmSettings(@NotNull JpsProject project, @NotNull K2JVMCompilerArguments k2JvmCompilerSettings) {
+    public static void setK2JvmCompilerArguments(@NotNull JpsProject project, @NotNull K2JVMCompilerArguments k2JvmCompilerArguments) {
-        getOrCreateSettings(project).k2JvmCompilerSettings = k2JvmCompilerSettings;
+        getOrCreateSettings(project).k2JvmCompilerArguments = k2JvmCompilerArguments;
     }
 
     @NotNull
-    public static K2JSCompilerArguments getK2JsSettings(@NotNull JpsProject project) {
+    public static K2JSCompilerArguments getK2JsCompilerArguments(@NotNull JpsProject project) {
-        return getSettings(project).k2JsCompilerSettings;
+        return getSettings(project).k2JsCompilerArguments;
     }
 
-    public static void setK2JsSettings(@NotNull JpsProject project, @NotNull K2JSCompilerArguments k2JsCompilerSettings) {
+    public static void setK2JsCompilerArguments(@NotNull JpsProject project, @NotNull K2JSCompilerArguments k2JsCompilerArguments) {
-        getOrCreateSettings(project).k2JsCompilerSettings = k2JsCompilerSettings;
+        getOrCreateSettings(project).k2JsCompilerArguments = k2JsCompilerArguments;
     }
 
     @NotNull
-    public static AdditionalCompilerSettings getAdditionalSettings(@NotNull JpsProject project) {
+    public static CompilerSettings getCompilerSettings(@NotNull JpsProject project) {
-        return getSettings(project).additionalCompilerSettings;
+        return getSettings(project).compilerSettings;
     }
 
-    public static void setAdditionalSettings(@NotNull JpsProject project, @NotNull AdditionalCompilerSettings additionalCompilerSettings) {
+    public static void setCompilerSettings(@NotNull JpsProject project, @NotNull CompilerSettings compilerSettings) {
-        getOrCreateSettings(project).additionalCompilerSettings = additionalCompilerSettings;
+        getOrCreateSettings(project).compilerSettings = compilerSettings;
     }
 }

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

@@ -27,7 +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.CompilerSettings;
 import org.jetbrains.jet.compiler.runner.CompilerEnvironment;
 import org.jetbrains.jet.compiler.runner.CompilerRunnerConstants;
 import org.jetbrains.jet.compiler.runner.OutputItemsCollectorImpl;
@@ -117,8 +117,8 @@ public class KotlinBuilder extends ModuleLevelBuilder {
         OutputItemsCollectorImpl outputItemCollector = new OutputItemsCollectorImpl();
 
         JpsProject project = representativeTarget.getModule().getProject();
-        CommonCompilerArguments commonSettings = JpsKotlinCompilerSettings.getCommonSettings(project);
+        CommonCompilerArguments commonArguments = JpsKotlinCompilerSettings.getCommonCompilerArguments(project);
-        AdditionalCompilerSettings additionalSettings = JpsKotlinCompilerSettings.getAdditionalSettings(project);
+        CompilerSettings compilerSettings = JpsKotlinCompilerSettings.getCompilerSettings(project);
 
         if (JpsUtils.isJsKotlinModule(representativeTarget)) {
             if (chunk.getModules().size() > 1) {
@@ -141,9 +141,9 @@ public class KotlinBuilder extends ModuleLevelBuilder {
 
             File outputFile = new File(outputDir, representativeTarget.getModule().getName() + ".js");
             List<String> libraryFiles = JpsJsModuleUtils.getLibraryFilesAndDependencies(representativeTarget);
-            K2JSCompilerArguments k2JsSettings = JpsKotlinCompilerSettings.getK2JsSettings(project);
+            K2JSCompilerArguments k2JsArguments = JpsKotlinCompilerSettings.getK2JsCompilerArguments(project);
 
-            runK2JsCompiler(commonSettings, k2JsSettings, additionalSettings, messageCollector, environment,
+            runK2JsCompiler(commonArguments, k2JsArguments, compilerSettings, messageCollector, environment,
                             outputItemCollector, sourceFiles, libraryFiles, outputFile);
         }
         else {
@@ -161,9 +161,9 @@ public class KotlinBuilder extends ModuleLevelBuilder {
                 return ExitCode.NOTHING_DONE;
             }
 
-            K2JVMCompilerArguments k2JvmSettings = JpsKotlinCompilerSettings.getK2JvmSettings(project);
+            K2JVMCompilerArguments k2JvmArguments = JpsKotlinCompilerSettings.getK2JvmCompilerArguments(project);
 
-            runK2JvmCompiler(commonSettings, k2JvmSettings, additionalSettings, messageCollector, environment,
+            runK2JvmCompiler(commonArguments, k2JvmArguments, compilerSettings, messageCollector, environment,
                              moduleFile, outputItemCollector);
         }
 

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

@@ -25,11 +25,11 @@ import org.jetbrains.jps.model.JpsProject;
 import org.jetbrains.jps.model.serialization.JpsProjectExtensionSerializer;
 
 import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMPILER_SETTINGS_FILE;
-import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_TO_JS_COMPILER_SETTINGS_SECTION;
+import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_TO_JS_COMPILER_ARGUMENTS_SECTION;
 
-class Kotlin2JsCompilerSettingsSerializer extends JpsProjectExtensionSerializer {
+class Kotlin2JsCompilerArgumentsSerializer extends JpsProjectExtensionSerializer {
-    Kotlin2JsCompilerSettingsSerializer() {
+    Kotlin2JsCompilerArgumentsSerializer() {
-        super(KOTLIN_COMPILER_SETTINGS_FILE, KOTLIN_TO_JS_COMPILER_SETTINGS_SECTION);
+        super(KOTLIN_COMPILER_SETTINGS_FILE, KOTLIN_TO_JS_COMPILER_ARGUMENTS_SECTION);
     }
 
     @Override
@@ -39,7 +39,7 @@ class Kotlin2JsCompilerSettingsSerializer extends JpsProjectExtensionSerializer
             settings = new K2JSCompilerArguments();
         }
 
-        JpsKotlinCompilerSettings.setK2JsSettings(project, settings);
+        JpsKotlinCompilerSettings.setK2JsCompilerArguments(project, settings);
     }
 
     @Override

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

@@ -25,11 +25,11 @@ import org.jetbrains.jps.model.JpsProject;
 import org.jetbrains.jps.model.serialization.JpsProjectExtensionSerializer;
 
 import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMPILER_SETTINGS_FILE;
-import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_TO_JVM_COMPILER_SETTINGS_SECTION;
+import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_TO_JVM_COMPILER_ARGUMENTS_SECTION;
 
-class Kotlin2JvmCompilerSettingsSerializer extends JpsProjectExtensionSerializer {
+class Kotlin2JvmCompilerArgumentsSerializer extends JpsProjectExtensionSerializer {
-    Kotlin2JvmCompilerSettingsSerializer() {
+    Kotlin2JvmCompilerArgumentsSerializer() {
-        super(KOTLIN_COMPILER_SETTINGS_FILE, KOTLIN_TO_JVM_COMPILER_SETTINGS_SECTION);
+        super(KOTLIN_COMPILER_SETTINGS_FILE, KOTLIN_TO_JVM_COMPILER_ARGUMENTS_SECTION);
     }
 
     @Override
@@ -39,7 +39,7 @@ class Kotlin2JvmCompilerSettingsSerializer extends JpsProjectExtensionSerializer
             settings = new K2JVMCompilerArguments();
         }
 
-        JpsKotlinCompilerSettings.setK2JvmSettings(project, settings);
+        JpsKotlinCompilerSettings.setK2JvmCompilerArguments(project, settings);
     }
 
     @Override

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

@@ -24,12 +24,12 @@ 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_COMMON_COMPILER_SETTINGS_SECTION;
+import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMMON_COMPILER_ARGUMENTS_SECTION;
 import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMPILER_SETTINGS_FILE;
 
-class KotlinCommonCompilerSettingsSerializer extends JpsProjectExtensionSerializer {
+class KotlinCommonCompilerArgumentsSerializer extends JpsProjectExtensionSerializer {
-    KotlinCommonCompilerSettingsSerializer() {
+    KotlinCommonCompilerArgumentsSerializer() {
-        super(KOTLIN_COMPILER_SETTINGS_FILE, KOTLIN_COMMON_COMPILER_SETTINGS_SECTION);
+        super(KOTLIN_COMPILER_SETTINGS_FILE, KOTLIN_COMMON_COMPILER_ARGUMENTS_SECTION);
     }
 
     @Override
@@ -39,7 +39,7 @@ class KotlinCommonCompilerSettingsSerializer extends JpsProjectExtensionSerializ
             settings = new CommonCompilerArguments.DummyImpl();
         }
 
-        JpsKotlinCompilerSettings.setCommonSettings(project, settings);
+        JpsKotlinCompilerSettings.setCommonCompilerArguments(project, settings);
     }
 
     @Override

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

@@ -19,27 +19,27 @@ 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.compiler.CompilerSettings;
 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_SECTION;
 import static org.jetbrains.jet.compiler.SettingConstants.KOTLIN_COMPILER_SETTINGS_FILE;
 
-class KotlinAdditionalCompilerSettingsSerializer extends JpsProjectExtensionSerializer {
+class KotlinCompilerSettingsSerializer extends JpsProjectExtensionSerializer {
-    KotlinAdditionalCompilerSettingsSerializer() {
+    KotlinCompilerSettingsSerializer() {
-        super(KOTLIN_COMPILER_SETTINGS_FILE, KOTLIN_ADDITIONAL_COMPILER_SETTINGS_SECTION);
+        super(KOTLIN_COMPILER_SETTINGS_FILE, KOTLIN_COMPILER_SETTINGS_SECTION);
     }
 
     @Override
     public void loadExtension(@NotNull JpsProject project, @NotNull Element componentTag) {
-        AdditionalCompilerSettings settings = XmlSerializer.deserialize(componentTag, AdditionalCompilerSettings.class);
+        CompilerSettings settings = XmlSerializer.deserialize(componentTag, CompilerSettings.class);
         if (settings == null) {
-            settings = new AdditionalCompilerSettings();
+            settings = new CompilerSettings();
         }
 
-        JpsKotlinCompilerSettings.setAdditionalSettings(project, settings);
+        JpsKotlinCompilerSettings.setCompilerSettings(project, settings);
     }
 
     @Override

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

@@ -27,9 +27,9 @@ public class KotlinModelSerializerService extends JpsModelSerializerExtension {
     @NotNull
     @Override
     public List<? extends JpsProjectExtensionSerializer> getProjectExtensionSerializers() {
-        return Arrays.asList(new KotlinCommonCompilerSettingsSerializer(),
+        return Arrays.asList(new KotlinCommonCompilerArgumentsSerializer(),
-                             new Kotlin2JvmCompilerSettingsSerializer(),
+                             new Kotlin2JvmCompilerArgumentsSerializer(),
-                             new Kotlin2JsCompilerSettingsSerializer(),
+                             new Kotlin2JsCompilerArgumentsSerializer(),
-                             new KotlinAdditionalCompilerSettingsSerializer());
+                             new KotlinCompilerSettingsSerializer());
     }
 }