J2K: CommonToolArguments and inheritors

build-common/src/org/jetbrains/kotlin/compilerRunner/ArgumentUtils.java

@@ -36,7 +36,7 @@ public class ArgumentUtils {
             throws InstantiationException, IllegalAccessException {
         List<String> result = new ArrayList<>();
         convertArgumentsToStringList(arguments, arguments.getClass().newInstance(), arguments.getClass(), result);
-        result.addAll(arguments.freeArgs);
+        result.addAll(arguments.getFreeArgs());
         return result;
     }
 

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt

@@ -14,50 +14,53 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.cli.common.arguments;
+package org.jetbrains.kotlin.cli.common.arguments
 
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.config.AnalysisFlag
-import org.jetbrains.kotlin.config.AnalysisFlag;
+import java.util.*
-
-import java.util.HashMap;
-import java.util.Map;
 
 @SuppressWarnings("WeakerAccess")
-public abstract class CommonCompilerArguments extends CommonToolArguments {
+abstract class CommonCompilerArguments : CommonToolArguments() {
-    public static final long serialVersionUID = 0L;
+    companion object {
+        @JvmStatic private val serialVersionUID = 0L
 
-    public static final String PLUGIN_OPTION_FORMAT = "plugin:<pluginId>:<optionName>=<value>";
+        const val PLUGIN_OPTION_FORMAT = "plugin:<pluginId>:<optionName>=<value>"
 
-    @GradleOption(DefaultValues.LanguageVersions.class)
+        const val WARN = "warn"
+        const val ERROR = "error"
+        const val ENABLE = "enable"
+    }
+
+    @GradleOption(DefaultValues.LanguageVersions::class)
     @Argument(
             value = "-language-version",
             valueDescription = "<version>",
             description = "Provide source compatibility with specified language version"
     )
-    public String languageVersion;
+    var languageVersion: String? = null
 
-    @GradleOption(DefaultValues.LanguageVersions.class)
+    @GradleOption(DefaultValues.LanguageVersions::class)
     @Argument(
             value = "-api-version",
             valueDescription = "<version>",
             description = "Allow to use declarations only from the specified version of bundled libraries"
     )
-    public String apiVersion;
+    var apiVersion: String? = null
 
     @Argument(
             value = "-kotlin-home",
             valueDescription = "<path>",
             description = "Path to Kotlin compiler home directory, used for runtime libraries discovery"
     )
-    public String kotlinHome;
+    var kotlinHome: String? = null
 
     @Argument(value = "-P", valueDescription = PLUGIN_OPTION_FORMAT, description = "Pass an option to a plugin")
-    public String[] pluginOptions;
+    var pluginOptions: Array<String>? = null
 
     // Advanced options
 
     @Argument(value = "-Xno-inline", description = "Disable method inlining")
-    public boolean noInline;
+    var noInline: Boolean = false
 
     // TODO Remove in 1.0
     @Argument(
@@ -65,52 +68,50 @@ public abstract class CommonCompilerArguments extends CommonToolArguments {
             valueDescription = "<count>",
             description = "Repeat compilation (for performance analysis)"
     )
-    public String repeat;
+    var repeat: String? = null
 
-    @Argument(value = "-Xskip-metadata-version-check", description = "Load classes with bad metadata version anyway (incl. pre-release classes)")
+    @Argument(
-    public boolean skipMetadataVersionCheck;
+            value = "-Xskip-metadata-version-check",
+            description = "Load classes with bad metadata version anyway (incl. pre-release classes)"
+    )
+    var skipMetadataVersionCheck: Boolean = false
 
     @Argument(value = "-Xallow-kotlin-package", description = "Allow compiling code in package 'kotlin'")
-    public boolean allowKotlinPackage;
+    var allowKotlinPackage: Boolean = false
 
     @Argument(value = "-Xreport-output-files", description = "Report source to output files mapping")
-    public boolean reportOutputFiles;
+    var reportOutputFiles: Boolean = false
 
     @Argument(value = "-Xplugin", valueDescription = "<path>", description = "Load plugins from the given classpath")
-    public String[] pluginClasspaths;
+    var pluginClasspaths: Array<String>? = null
 
     @Argument(value = "-Xmulti-platform", description = "Enable experimental language support for multi-platform projects")
-    public boolean multiPlatform;
+    var multiPlatform: Boolean = false
 
     @Argument(value = "-Xno-check-impl", description = "Do not check presence of 'impl' modifier in multi-platform projects")
-    public boolean noCheckImpl;
+    var noCheckImpl: Boolean = false
 
     @Argument(
             value = "-Xintellij-plugin-root",
             valueDescription = "<path>",
             description = "Path to the kotlin-compiler.jar or directory where IntelliJ configuration files can be found"
     )
-    public String intellijPluginRoot;
+    var intellijPluginRoot: String? = null
 
     @Argument(
             value = "-Xcoroutines",
             valueDescription = "{enable|warn|error}",
             description = "Enable coroutines or report warnings or errors on declarations and use sites of 'suspend' modifier"
     )
-    public String coroutinesState = WARN;
+    var coroutinesState: String? = WARN
 
-    public static final String WARN = "warn";
+    open fun configureAnalysisFlags(): MutableMap<AnalysisFlag<*>, Any> {
-    public static final String ERROR = "error";
+        return HashMap<AnalysisFlag<*>, Any>().apply {
-    public static final String ENABLE = "enable";
+            put(AnalysisFlag.skipMetadataVersionCheck, skipMetadataVersionCheck)
-
+            put(AnalysisFlag.multiPlatformDoNotCheckImpl, noCheckImpl)
-    @NotNull
+        }
-    public Map<AnalysisFlag<?>, Object> configureAnalysisFlags() {
-        Map<AnalysisFlag<?>, Object> result = new HashMap<>();
-        result.put(AnalysisFlag.getSkipMetadataVersionCheck(), skipMetadataVersionCheck);
-        result.put(AnalysisFlag.getMultiPlatformDoNotCheckImpl(), noCheckImpl);
-        return result;
     }
 
     // Used only for serialize and deserialize settings. Don't use in other places!
-    public static final class DummyImpl extends CommonCompilerArguments {}
+    class DummyImpl : CommonCompilerArguments()
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonToolArguments.kt

@@ -14,34 +14,34 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.cli.common.arguments;
+package org.jetbrains.kotlin.cli.common.arguments
 
-import org.jetbrains.kotlin.utils.SmartList;
+import org.jetbrains.kotlin.utils.SmartList
+import java.io.Serializable
 
-import java.io.Serializable;
+abstract class CommonToolArguments : Serializable {
-import java.util.List;
+    companion object {
+        @JvmStatic private val serialVersionUID = 0L
+    }
 
-public abstract class CommonToolArguments implements Serializable {
+    var freeArgs: MutableList<String> = SmartList()
-    private static final long serialVersionUID = 0L;
 
-    public List<String> freeArgs = new SmartList<>();
+    @Transient var errors: ArgumentParseErrors = ArgumentParseErrors()
-
-    public transient ArgumentParseErrors errors = new ArgumentParseErrors();
 
     @Argument(value = "-help", shortName = "-h", description = "Print a synopsis of standard options")
-    public boolean help;
+    var help: Boolean = false
 
     @Argument(value = "-X", description = "Print a synopsis of advanced options")
-    public boolean extraHelp;
+    var extraHelp: Boolean = false
 
     @Argument(value = "-version", description = "Display compiler version")
-    public boolean version;
+    var version: Boolean = false
 
-    @GradleOption(DefaultValues.BooleanFalseDefault.class)
+    @GradleOption(DefaultValues.BooleanFalseDefault::class)
     @Argument(value = "-verbose", description = "Enable verbose logging output")
-    public boolean verbose;
+    var verbose: Boolean = false
 
-    @GradleOption(DefaultValues.BooleanFalseDefault.class)
+    @GradleOption(DefaultValues.BooleanFalseDefault::class)
     @Argument(value = "-nowarn", description = "Generate no warnings")
-    public boolean suppressWarnings;
+    var suppressWarnings: Boolean = false
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JSCompilerArguments.kt

@@ -14,100 +14,102 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.cli.common.arguments;
+package org.jetbrains.kotlin.cli.common.arguments
 
-import static org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.CALL;
+import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.CALL
-import static org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.NO_CALL;
+import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.NO_CALL
 
-public class K2JSCompilerArguments extends CommonCompilerArguments {
+class K2JSCompilerArguments : CommonCompilerArguments() {
-    public static final long serialVersionUID = 0L;
+    companion object {
+        @JvmStatic private val serialVersionUID = 0L
+    }
 
-    @GradleOption(DefaultValues.StringNullDefault.class)
+    @GradleOption(DefaultValues.StringNullDefault::class)
     @Argument(value = "-output", valueDescription = "<path>", description = "Output file path")
-    public String outputFile;
+    var outputFile: String? = null
 
-    @GradleOption(DefaultValues.BooleanTrueDefault.class)
+    @GradleOption(DefaultValues.BooleanTrueDefault::class)
     @Argument(value = "-no-stdlib", description = "Don't use bundled Kotlin stdlib")
-    public boolean noStdlib;
+    var noStdlib: Boolean = false
 
     @Argument(
             value = "-libraries",
             valueDescription = "<path>",
             description = "Paths to Kotlin libraries with .meta.js and .kjsm files, separated by system path separator"
     )
-    public String libraries;
+    var libraries: String? = null
 
-    @GradleOption(DefaultValues.BooleanFalseDefault.class)
+    @GradleOption(DefaultValues.BooleanFalseDefault::class)
     @Argument(value = "-source-map", description = "Generate source map")
-    public boolean sourceMap;
+    var sourceMap: Boolean = false
 
-    @GradleOption(DefaultValues.StringNullDefault.class)
+    @GradleOption(DefaultValues.StringNullDefault::class)
     @Argument(value = "-source-map-prefix", description = "Prefix for paths in a source map")
-    public String sourceMapPrefix;
+    var sourceMapPrefix: String? = null
 
     @Argument(
             value = "-source-map-source-roots",
             valueDescription = "<path>",
             description = "Base directories which are used to calculate relative paths to source files in source map"
     )
-    public String sourceMapSourceRoots;
+    var sourceMapSourceRoots: String? = null
 
-    @GradleOption(DefaultValues.JsSourceMapContentModes.class)
+    @GradleOption(DefaultValues.JsSourceMapContentModes::class)
     @Argument(
             value = "-source-map-embed-sources",
             valueDescription = "{ always, never, inlining }",
             description = "Embed source files into source map"
     )
-    public String sourceMapEmbedSources;
+    var sourceMapEmbedSources: String? = null
 
-    @GradleOption(DefaultValues.BooleanTrueDefault.class)
+    @GradleOption(DefaultValues.BooleanTrueDefault::class)
     @Argument(value = "-meta-info", description = "Generate .meta.js and .kjsm files with metadata. Use to create a library")
-    public boolean metaInfo;
+    var metaInfo: Boolean = false
 
-    @GradleOption(DefaultValues.JsEcmaVersions.class)
+    @GradleOption(DefaultValues.JsEcmaVersions::class)
     @Argument(value = "-target", valueDescription = "{ v5 }", description = "Generate JS files for specific ECMA version")
-    public String target;
+    var target: String? = null
 
-    @GradleOption(DefaultValues.JsModuleKinds.class)
+    @GradleOption(DefaultValues.JsModuleKinds::class)
     @Argument(
             value = "-module-kind",
             valueDescription = "{ plain, amd, commonjs, umd }",
             description = "Kind of a module generated by compiler"
     )
-    public String moduleKind = K2JsArgumentConstants.MODULE_PLAIN;
+    var moduleKind: String? = K2JsArgumentConstants.MODULE_PLAIN
 
-    @GradleOption(DefaultValues.JsMain.class)
+    @GradleOption(DefaultValues.JsMain::class)
-    @Argument(value = "-main", valueDescription = "{" + CALL + "," + NO_CALL + "}", description = "Whether a main function should be called")
+    @Argument(value = "-main", valueDescription = "{$CALL,$NO_CALL}", description = "Whether a main function should be called")
-    public String main;
+    var main: String? = null
 
     @Argument(
             value = "-output-prefix",
             valueDescription = "<path>",
             description = "Path to file which will be added to the beginning of output file"
     )
-    public String outputPrefix;
+    var outputPrefix: String? = null
 
     @Argument(
             value = "-output-postfix",
             valueDescription = "<path>",
             description = "Path to file which will be added to the end of output file"
     )
-    public String outputPostfix;
+    var outputPostfix: String? = null
 
     // Advanced options
 
-    @GradleOption(DefaultValues.BooleanFalseDefault.class)
+    @GradleOption(DefaultValues.BooleanFalseDefault::class)
     @Argument(value = "-Xtyped-arrays", description = "Translate primitive arrays to JS typed arrays")
-    public boolean typedArrays;
+    var typedArrays: Boolean = false
 
-    @GradleOption(DefaultValues.BooleanFalseDefault.class)
+    @GradleOption(DefaultValues.BooleanFalseDefault::class)
     @Argument(value = "-Xfriend-modules-disabled", description = "Disable internal declaration export")
-    public boolean friendModulesDisabled;
+    var friendModulesDisabled: Boolean = false
 
     @Argument(
             value = "-Xfriend-modules",
             valueDescription = "<path>",
             description = "Paths to friend modules"
     )
-    public String friendModules;
+    var friendModules: String? = null
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JSDceArguments.kt

@@ -14,28 +14,30 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.cli.common.arguments;
+package org.jetbrains.kotlin.cli.common.arguments
 
-public class K2JSDceArguments extends CommonToolArguments {
+class K2JSDceArguments : CommonToolArguments() {
-    private static final long serialVersionUID = 0;
+    companion object {
+        @JvmStatic private val serialVersionUID = 0L
+    }
 
     @Argument(
             value = "-output-dir",
             valueDescription = "<path>",
             description = "Output directory"
     )
-    public String outputDirectory;
+    var outputDirectory: String? = null
 
     @Argument(
             value = "-keep",
             valueDescription = "<fully.qualified.name[,]>",
             description = "List of fully-qualified names of declarations that shouldn't be eliminated"
     )
-    public String[] declarationsToKeep;
+    var declarationsToKeep: Array<String>? = null
 
     @Argument(
             value = "-Xprint-reachability-info",
             description = "Print declarations marked as reachable"
     )
-    public boolean printReachabilityInfo;
+    var printReachabilityInfo: Boolean = false
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt

@@ -14,78 +14,76 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.cli.common.arguments;
+package org.jetbrains.kotlin.cli.common.arguments
 
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.config.AnalysisFlag
-import org.jetbrains.kotlin.config.AnalysisFlag;
+import org.jetbrains.kotlin.config.Jsr305State
-import org.jetbrains.kotlin.config.Jsr305State;
+import org.jetbrains.kotlin.config.JvmTarget
-import org.jetbrains.kotlin.config.JvmTarget;
 
-import java.util.Map;
+class K2JVMCompilerArguments : CommonCompilerArguments() {
-
+    companion object {
-@SuppressWarnings("WeakerAccess")
+        @JvmStatic private val serialVersionUID = 0L
-public class K2JVMCompilerArguments extends CommonCompilerArguments {
+    }
-    public static final long serialVersionUID = 0L;
 
     @Argument(value = "-d", valueDescription = "<directory|jar>", description = "Destination for generated class files")
-    public String destination;
+    var destination: String? = null
 
     @Argument(value = "-classpath", shortName = "-cp", valueDescription = "<path>", description = "Paths where to find user class files")
-    public String classpath;
+    var classpath: String? = null
 
-    @GradleOption(DefaultValues.BooleanFalseDefault.class)
+    @GradleOption(DefaultValues.BooleanFalseDefault::class)
     @Argument(value = "-include-runtime", description = "Include Kotlin runtime in to resulting .jar")
-    public boolean includeRuntime;
+    var includeRuntime: Boolean = false
 
-    @GradleOption(DefaultValues.StringNullDefault.class)
+    @GradleOption(DefaultValues.StringNullDefault::class)
     @Argument(
             value = "-jdk-home",
             valueDescription = "<path>",
             description = "Path to JDK home directory to include into classpath, if differs from default JAVA_HOME"
     )
-    public String jdkHome;
+    var jdkHome: String? = null
 
-    @GradleOption(DefaultValues.BooleanFalseDefault.class)
+    @GradleOption(DefaultValues.BooleanFalseDefault::class)
     @Argument(value = "-no-jdk", description = "Don't include Java runtime into classpath")
-    public boolean noJdk;
+    var noJdk: Boolean = false
 
-    @GradleOption(DefaultValues.BooleanTrueDefault.class)
+    @GradleOption(DefaultValues.BooleanTrueDefault::class)
     @Argument(value = "-no-stdlib", description = "Don't include Kotlin runtime into classpath")
-    public boolean noStdlib;
+    var noStdlib: Boolean = false
 
-    @GradleOption(DefaultValues.BooleanTrueDefault.class)
+    @GradleOption(DefaultValues.BooleanTrueDefault::class)
     @Argument(value = "-no-reflect", description = "Don't include Kotlin reflection implementation into classpath")
-    public boolean noReflect;
+    var noReflect: Boolean = false
 
     @Argument(value = "-script", description = "Evaluate the script file")
-    public boolean script;
+    var script: Boolean = false
 
     @Argument(
             value = "-script-templates",
             valueDescription = "<fully qualified class name[,]>",
             description = "Script definition template classes"
     )
-    public String[] scriptTemplates;
+    var scriptTemplates: Array<String>? = null
 
     @Argument(value = "-module-name", description = "Module name")
-    public String moduleName;
+    var moduleName: String? = null
 
-    @GradleOption(DefaultValues.JvmTargetVersions.class)
+    @GradleOption(DefaultValues.JvmTargetVersions::class)
     @Argument(
             value = "-jvm-target",
             valueDescription = "<version>",
             description = "Target version of the generated JVM bytecode (1.6 or 1.8), default is 1.6"
     )
-    public String jvmTarget = JvmTarget.DEFAULT.getDescription();
+    var jvmTarget: String? = JvmTarget.DEFAULT.description
 
-    @GradleOption(DefaultValues.BooleanFalseDefault.class)
+    @GradleOption(DefaultValues.BooleanFalseDefault::class)
     @Argument(value = "-java-parameters", description = "Generate metadata for Java 1.8 reflection on method parameters")
-    public boolean javaParameters;
+    var javaParameters: Boolean = false
 
     // Advanced options
 
     @Argument(value = "-Xmodule-path", valueDescription = "<path>", description = "Paths where to find Java 9+ modules")
-    public String javaModulePath;
+    var javaModulePath: String? = null
 
     @Argument(
             value = "-Xadd-modules",
@@ -93,89 +91,84 @@ public class K2JVMCompilerArguments extends CommonCompilerArguments {
             description = "Root modules to resolve in addition to the initial modules,\n" +
                           "or all modules on the module path if <module> is ALL-MODULE-PATH"
     )
-    public String[] additionalJavaModules;
+    var additionalJavaModules: Array<String>? = null
 
     @Argument(value = "-Xno-call-assertions", description = "Don't generate not-null assertion after each invocation of method returning not-null")
-    public boolean noCallAssertions;
+    var noCallAssertions: Boolean = false
 
     @Argument(value = "-Xno-param-assertions", description = "Don't generate not-null assertions on parameters of methods accessible from Java")
-    public boolean noParamAssertions;
+    var noParamAssertions: Boolean = false
 
     @Argument(value = "-Xno-optimize", description = "Disable optimizations")
-    public boolean noOptimize;
+    var noOptimize: Boolean = false
 
     @Argument(value = "-Xreport-perf", description = "Report detailed performance statistics")
-    public boolean reportPerf;
+    var reportPerf: Boolean = false
 
     @Argument(value = "-Xbuild-file", deprecatedName = "-module", valueDescription = "<path>", description = "Path to the .xml build file to compile")
-    public String buildFile;
+    var buildFile: String? = null
 
     @Argument(value = "-Xmultifile-parts-inherit", description = "Compile multifile classes as a hierarchy of parts and facade")
-    public boolean inheritMultifileParts;
+    var inheritMultifileParts: Boolean = false
 
     @Argument(value = "-Xskip-runtime-version-check", description = "Allow Kotlin runtime libraries of incompatible versions in the classpath")
-    public boolean skipRuntimeVersionCheck;
+    var skipRuntimeVersionCheck: Boolean = false
 
     @Argument(
             value = "-Xuse-old-class-files-reading",
             description = "Use old class files reading implementation " +
                           "(may slow down the build and should be used in case of problems with the new implementation)"
     )
-    public boolean useOldClassFilesReading;
+    var useOldClassFilesReading: Boolean = false
 
     @Argument(
             value = "-Xdump-declarations-to",
             valueDescription = "<path>",
             description = "Path to JSON file to dump Java to Kotlin declaration mappings"
     )
-    public String declarationsOutputPath;
+    var declarationsOutputPath: String? = null
 
     @Argument(value = "-Xsingle-module", description = "Combine modules for source files and binary dependencies into a single module")
-    public boolean singleModule;
+    var singleModule: Boolean = false
 
     @Argument(value = "-Xadd-compiler-builtins", description = "Add definitions of built-in declarations to the compilation classpath (useful with -no-stdlib)")
-    public boolean addCompilerBuiltIns;
+    var addCompilerBuiltIns: Boolean = false
 
     @Argument(value = "-Xload-builtins-from-dependencies", description = "Load definitions of built-in declarations from module dependencies, instead of from the compiler")
-    public boolean loadBuiltInsFromDependencies;
+    var loadBuiltInsFromDependencies: Boolean = false
 
     @Argument(
             value = "-Xscript-resolver-environment",
             valueDescription = "<key=value[,]>",
             description = "Script resolver environment in key-value pairs (the value could be quoted and escaped)"
     )
-    public String[] scriptResolverEnvironment;
+    var scriptResolverEnvironment: Array<String>? = null
 
     // Javac options
     @Argument(value = "-Xuse-javac", description = "Use javac for Java source and class files analysis")
-    public boolean useJavac;
+    var useJavac: Boolean = false
 
     @Argument(
             value = "-Xjavac-arguments",
             valueDescription = "<option[,]>",
             description = "Java compiler arguments")
-    public String[] javacArguments;
+    var javacArguments: Array<String>? = null
 
     @Argument(
             value = "-Xjsr305-annotations",
             valueDescription = "{ignore|enable}",
             description = "Specify global behavior for JSR-305 nullability annotations: ignore, or treat as other supported nullability annotations"
     )
-    public String jsr305GlobalReportLevel = Jsr305State.DEFAULT.getDescription();
+    var jsr305GlobalReportLevel: String? = Jsr305State.DEFAULT.description
 
     // Paths to output directories for friend modules.
-    public String[] friendPaths;
+    var friendPaths: Array<String>? = null
 
-    @Override
+    override fun configureAnalysisFlags(): MutableMap<AnalysisFlag<*>, Any> {
-    @NotNull
+        val result = super.configureAnalysisFlags()
-    public Map<AnalysisFlag<?>, Object> configureAnalysisFlags() {
+        Jsr305State.values().firstOrNull { it.description == jsr305GlobalReportLevel }?.let {
-        Map<AnalysisFlag<?>, Object> result = super.configureAnalysisFlags();
+            result.put(AnalysisFlag.loadJsr305Annotations, it)
-        for (Jsr305State state : Jsr305State.values()) {
-            if (state.getDescription().equals(jsr305GlobalReportLevel)) {
-                result.put(AnalysisFlag.getLoadJsr305Annotations(), state);
-                break;
-            }
         }
-        return result;
+        return result
     }
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2MetadataCompilerArguments.kt

@@ -14,13 +14,15 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.cli.common.arguments;
+package org.jetbrains.kotlin.cli.common.arguments
 
-public class K2MetadataCompilerArguments extends CommonCompilerArguments {
+class K2MetadataCompilerArguments : CommonCompilerArguments() {
-    public static final long serialVersionUID = 0L;
+    companion object {
+        @JvmStatic private val serialVersionUID = 0L
+    }
 
     @Argument(value = "-d", valueDescription = "<directory|jar>", description = "Destination for generated .kotlin_metadata files")
-    public String destination;
+    var destination: String? = null
 
     @Argument(
             value = "-classpath",
@@ -28,5 +30,5 @@ public class K2MetadataCompilerArguments extends CommonCompilerArguments {
             valueDescription = "<path>",
             description = "Paths where to find library .kotlin_metadata files"
     )
-    public String classpath;
+    var classpath: String? = null
 }

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

@@ -81,9 +81,10 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
             ExitCode exitCode = OK;
 
             int repeatCount = 1;
-            if (arguments.repeat != null) {
+            String repeat = arguments.getRepeat();
+            if (repeat != null) {
                 try {
-                    repeatCount = Integer.parseInt(arguments.repeat);
+                    repeatCount = Integer.parseInt(repeat);
                 }
                 catch (NumberFormatException ignored) {
                 }
@@ -134,13 +135,13 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
     private void setupCommonArgumentsAndServices(
             @NotNull CompilerConfiguration configuration, @NotNull A arguments, @NotNull Services services
     ) {
-        if (arguments.noInline) {
+        if (arguments.getNoInline()) {
             configuration.put(CommonConfigurationKeys.DISABLE_INLINE, true);
         }
-        if (arguments.intellijPluginRoot != null) {
+        if (arguments.getIntellijPluginRoot()!= null) {
-            configuration.put(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT, arguments.intellijPluginRoot);
+            configuration.put(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT, arguments.getIntellijPluginRoot());
         }
-        if (arguments.reportOutputFiles) {
+        if (arguments.getReportOutputFiles()) {
             configuration.put(CommonConfigurationKeys.REPORT_OUTPUT_FILES, true);
         }
         @SuppressWarnings("deprecation")
@@ -153,8 +154,8 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
     }
 
     private void setupLanguageVersionSettings(@NotNull CompilerConfiguration configuration, @NotNull A arguments) {
-        LanguageVersion languageVersion = parseVersion(configuration, arguments.languageVersion, "language");
+        LanguageVersion languageVersion = parseVersion(configuration, arguments.getLanguageVersion(), "language");
-        LanguageVersion apiVersion = parseVersion(configuration, arguments.apiVersion, "API");
+        LanguageVersion apiVersion = parseVersion(configuration, arguments.getApiVersion(), "API");
 
         if (languageVersion == null) {
             // If only "-api-version" is specified, language version is assumed to be the latest stable
@@ -189,7 +190,7 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
         }
 
         Map<LanguageFeature, LanguageFeature.State> extraLanguageFeatures = new HashMap<>(0);
-        if (arguments.multiPlatform) {
+        if (arguments.getMultiPlatform()) {
             extraLanguageFeatures.put(LanguageFeature.MultiPlatformProjects, LanguageFeature.State.ENABLED);
         }
 
@@ -209,8 +210,8 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
     @Nullable
     private static KotlinPaths computeKotlinPaths(@NotNull MessageCollector messageCollector, @NotNull CommonCompilerArguments arguments) {
         KotlinPaths paths;
-        if (arguments.kotlinHome != null) {
+        if (arguments.getKotlinHome() != null) {
-            File kotlinHome = new File(arguments.kotlinHome);
+            File kotlinHome = new File(arguments.getKotlinHome());
             if (kotlinHome.isDirectory()) {
                 paths = new KotlinPathsFromHomeDir(kotlinHome);
             }
@@ -256,7 +257,7 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
             @NotNull CompilerConfiguration configuration,
             @NotNull CommonCompilerArguments arguments
     ) {
-        switch (arguments.coroutinesState) {
+        switch (arguments.getCoroutinesState()) {
             case CommonCompilerArguments.ERROR:
                 return LanguageFeature.State.ENABLED_WITH_ERROR;
             case CommonCompilerArguments.ENABLE:
@@ -264,7 +265,7 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
             case CommonCompilerArguments.WARN:
                 return null;
             default:
-                String message = "Invalid value of -Xcoroutines (should be: enable, warn or error): " + arguments.coroutinesState;
+                String message = "Invalid value of -Xcoroutines (should be: enable, warn or error): " + arguments.getCoroutinesState();
                 configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY).report(ERROR, message, null);
                 return null;
         }

compiler/cli/src/org/jetbrains/kotlin/cli/common/Usage.java

@@ -32,14 +32,14 @@ public class Usage {
     public static <A extends CommonToolArguments> String render(@NotNull CLITool<A> tool, @NotNull A arguments) {
         StringBuilder sb = new StringBuilder();
         appendln(sb, "Usage: " + tool.executableScriptFileName() + " <options> <source files>");
-        appendln(sb, "where " + (arguments.extraHelp ? "advanced" : "possible") + " options include:");
+        appendln(sb, "where " + (arguments.getExtraHelp() ? "advanced" : "possible") + " options include:");
         for (Class<?> clazz = arguments.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
             for (Field field : clazz.getDeclaredFields()) {
-                fieldUsage(sb, field, arguments.extraHelp);
+                fieldUsage(sb, field, arguments.getExtraHelp());
             }
         }
 
-        if (arguments.extraHelp) {
+        if (arguments.getExtraHelp()) {
             appendln(sb, "");
             appendln(sb, "Advanced options are non-standard and may be changed or removed without any notice.");
         }

compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java

@@ -109,8 +109,8 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
     ) {
         MessageCollector messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY);
 
-        if (arguments.freeArgs.isEmpty()) {
+        if (arguments.getFreeArgs().isEmpty()) {
-            if (arguments.version) {
+            if (arguments.getVersion()) {
                 return OK;
             }
             messageCollector.report(ERROR, "Specify at least one source file or directory", null);
@@ -119,18 +119,18 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
 
         configuration.put(JSConfigurationKeys.LIBRARIES, configureLibraries(arguments, paths, messageCollector));
 
-        ContentRootsKt.addKotlinSourceRoots(configuration, arguments.freeArgs);
+        ContentRootsKt.addKotlinSourceRoots(configuration, arguments.getFreeArgs());
         KotlinCoreEnvironment environmentForJS =
                 KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES);
 
         Project project = environmentForJS.getProject();
         List<KtFile> sourcesFiles = environmentForJS.getSourceFiles();
 
-        environmentForJS.getConfiguration().put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage);
+        environmentForJS.getConfiguration().put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.getAllowKotlinPackage());
 
         if (!checkKotlinPackageUsage(environmentForJS, sourcesFiles)) return ExitCode.COMPILATION_ERROR;
 
-        if (arguments.outputFile == null) {
+        if (arguments.getOutputFile() == null) {
             messageCollector.report(ERROR, "Specify output file via -output", null);
             return ExitCode.COMPILATION_ERROR;
         }
@@ -144,11 +144,11 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
             return COMPILATION_ERROR;
         }
 
-        if (arguments.verbose) {
+        if (arguments.getVerbose()) {
             reportCompiledSourcesList(messageCollector, sourcesFiles);
         }
 
-        File outputFile = new File(arguments.outputFile);
+        File outputFile = new File(arguments.getOutputFile());
 
         configuration.put(CommonConfigurationKeys.MODULE_NAME, FileUtil.getNameWithoutExtension(outputFile));
 
@@ -181,19 +181,19 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
         JsAnalysisResult jsAnalysisResult = (JsAnalysisResult) analysisResult;
 
         File outputPrefixFile = null;
-        if (arguments.outputPrefix != null) {
+        if (arguments.getOutputPrefix() != null) {
-            outputPrefixFile = new File(arguments.outputPrefix);
+            outputPrefixFile = new File(arguments.getOutputPrefix());
             if (!outputPrefixFile.exists()) {
-                messageCollector.report(ERROR, "Output prefix file '" + arguments.outputPrefix + "' not found", null);
+                messageCollector.report(ERROR, "Output prefix file '" + arguments.getOutputPrefix() + "' not found", null);
                 return ExitCode.COMPILATION_ERROR;
             }
         }
 
         File outputPostfixFile = null;
-        if (arguments.outputPostfix != null) {
+        if (arguments.getOutputPrefix() != null) {
-            outputPostfixFile = new File(arguments.outputPostfix);
+            outputPostfixFile = new File(arguments.getOutputPrefix());
             if (!outputPostfixFile.exists()) {
-                messageCollector.report(ERROR, "Output postfix file '" + arguments.outputPostfix + "' not found", null);
+                messageCollector.report(ERROR, "Output postfix file '" + arguments.getOutputPostfix() + "' not found", null);
                 return ExitCode.COMPILATION_ERROR;
             }
         }
@@ -202,7 +202,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
             checkDuplicateSourceFileNames(messageCollector, sourcesFiles, config.getSourceMapRoots());
         }
 
-        MainCallParameters mainCallParameters = createMainCallParameters(arguments.main);
+        MainCallParameters mainCallParameters = createMainCallParameters(arguments.getMain());
         TranslationResult translationResult;
 
         K2JSTranslator translator = new K2JSTranslator(config);
@@ -294,47 +294,47 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
     ) {
         MessageCollector messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY);
 
-        if (arguments.target != null) {
+        if (arguments.getTarget() != null) {
-            assert arguments.target == "v5" : "Unsupported ECMA version: " + arguments.target;
+            assert arguments.getTarget() == "v5" : "Unsupported ECMA version: " + arguments.getTarget();
         }
         configuration.put(JSConfigurationKeys.TARGET, EcmaVersion.defaultVersion());
 
-        if (arguments.sourceMap) {
+        if (arguments.getSourceMap()) {
             configuration.put(JSConfigurationKeys.SOURCE_MAP, true);
-            if (arguments.sourceMapPrefix != null) {
+            if (arguments.getSourceMapPrefix() != null) {
-                configuration.put(JSConfigurationKeys.SOURCE_MAP_PREFIX, arguments.sourceMapPrefix);
+                configuration.put(JSConfigurationKeys.SOURCE_MAP_PREFIX, arguments.getSourceMapPrefix());
             }
 
-            String sourceMapSourceRoots = arguments.sourceMapSourceRoots != null ?
+            String sourceMapSourceRoots = arguments.getSourceMapSourceRoots() != null ?
-                                          arguments.sourceMapSourceRoots :
+                                          arguments.getSourceMapSourceRoots() :
                                           calculateSourceMapSourceRoot(messageCollector, arguments);
             List<String> sourceMapSourceRootList = StringUtil.split(sourceMapSourceRoots, File.pathSeparator);
             configuration.put(JSConfigurationKeys.SOURCE_MAP_SOURCE_ROOTS, sourceMapSourceRootList);
         }
         else {
-            if (arguments.sourceMapPrefix != null) {
+            if (arguments.getSourceMapPrefix() != null) {
                 messageCollector.report(WARNING, "source-map-prefix argument has no effect without source map", null);
             }
-            if (arguments.sourceMapSourceRoots != null) {
+            if (arguments.getSourceMapSourceRoots() != null) {
                 messageCollector.report(WARNING, "source-map-source-root argument has no effect without source map", null);
             }
         }
-        if (arguments.metaInfo) {
+        if (arguments.getMetaInfo()) {
             configuration.put(JSConfigurationKeys.META_INFO, true);
         }
 
-        if (arguments.typedArrays) {
+        if (arguments.getTypedArrays()) {
             configuration.put(JSConfigurationKeys.TYPED_ARRAYS_ENABLED, true);
         }
 
-        configuration.put(JSConfigurationKeys.FRIEND_PATHS_DISABLED, arguments.friendModulesDisabled);
+        configuration.put(JSConfigurationKeys.FRIEND_PATHS_DISABLED, arguments.getFriendModulesDisabled());
 
-        if (!arguments.friendModulesDisabled && arguments.friendModules != null) {
+        if (!arguments.getFriendModulesDisabled() && arguments.getFriendModules() != null) {
-            List<String> friendPaths = ArraysKt.filterNot(arguments.friendModules.split(File.pathSeparator), String::isEmpty);
+            List<String> friendPaths = ArraysKt.filterNot(arguments.getFriendModules().split(File.pathSeparator), String::isEmpty);
             configuration.put(JSConfigurationKeys.FRIEND_PATHS, friendPaths);
         }
 
-        String moduleKindName = arguments.moduleKind;
+        String moduleKindName = arguments.getModuleKind();
         ModuleKind moduleKind = moduleKindName != null ? moduleKindMap.get(moduleKindName) : ModuleKind.PLAIN;
         if (moduleKind == null) {
             messageCollector.report(
@@ -344,7 +344,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
         }
         configuration.put(JSConfigurationKeys.MODULE_KIND, moduleKind);
 
-        String sourceMapEmbedContentString = arguments.sourceMapEmbedSources;
+        String sourceMapEmbedContentString = arguments.getSourceMapEmbedSources();
         SourceMapSourceEmbedding sourceMapContentEmbedding = sourceMapEmbedContentString != null ?
                                                              sourceMapContentEmbeddingMap.get(sourceMapEmbedContentString) :
                                                              SourceMapSourceEmbedding.INLINING;
@@ -356,7 +356,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
         }
         configuration.put(JSConfigurationKeys.SOURCE_MAP_EMBED_SOURCES, sourceMapContentEmbedding);
 
-        if (!arguments.sourceMap && sourceMapEmbedContentString != null) {
+        if (!arguments.getSourceMap() && sourceMapEmbedContentString != null) {
             messageCollector.report(WARNING, "source-map-embed-sources argument has no effect without source map", null);
         }
     }
@@ -368,7 +368,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
             @NotNull MessageCollector messageCollector
     ) {
         List<String> libraries = new SmartList<>();
-        if (!arguments.noStdlib) {
+        if (!arguments.getNoStdlib()) {
             File stdlibJar = getLibraryFromHome(
                     paths, KotlinPaths::getJsStdLibJarPath, PathUtil.JS_LIB_JAR_NAME, messageCollector, "'-no-stdlib'");
             if (stdlibJar != null) {
@@ -376,8 +376,8 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
             }
         }
 
-        if (arguments.libraries != null) {
+        if (arguments.getLibraries() != null) {
-            libraries.addAll(ArraysKt.filterNot(arguments.libraries.split(File.pathSeparator), String::isEmpty));
+            libraries.addAll(ArraysKt.filterNot(arguments.getLibraries().split(File.pathSeparator), String::isEmpty));
         }
         return libraries;
     }
@@ -392,7 +392,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
         Map<File, Integer> pathToRootIndexes = new HashMap<>();
 
         try {
-            for (String path : arguments.freeArgs) {
+            for (String path : arguments.getFreeArgs()) {
                 File file = new File(path).getCanonicalFile();
                 if (commonPath == null) {
                     commonPath = file;

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt

@@ -122,7 +122,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
         }
 
         if (arguments.jvmTarget != null) {
-            val jvmTarget = JvmTarget.fromString(arguments.jvmTarget)
+            val jvmTarget = JvmTarget.fromString(arguments.jvmTarget!!)
             if (jvmTarget != null) {
                 configuration.put(JVMConfigurationKeys.JVM_TARGET, jvmTarget)
             }
@@ -487,7 +487,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
             val envParseRe = """(\w+)=(?:"([^"\\]*(\\.[^"\\]*)*)"|([^\s]*))""".toRegex()
             val unescapeRe = """\\(["\\])""".toRegex()
             if (arguments.scriptResolverEnvironment != null) {
-                for (envParam in arguments.scriptResolverEnvironment) {
+                for (envParam in arguments.scriptResolverEnvironment!!) {
                     val match = envParseRe.matchEntire(envParam)
                     if (match == null || match.groupValues.size < 4 || match.groupValues[1].isBlank()) {
                         messageCollector.report(ERROR, "Unable to parse script-resolver-environment argument $envParam")

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/K2MetadataCompiler.kt

@@ -57,7 +57,7 @@ class K2MetadataCompiler : CLICompiler<K2MetadataCompilerArguments>() {
             configuration.addKotlinSourceRoot(arg)
         }
         if (arguments.classpath != null) {
-            configuration.addJvmClasspathRoots(arguments.classpath.split(File.pathSeparatorChar).map(::File))
+            configuration.addJvmClasspathRoots(arguments.classpath!!.split(File.pathSeparatorChar).map(::File))
         }
 
         configuration.put(CommonConfigurationKeys.MODULE_NAME, JvmAbi.DEFAULT_MODULE_NAME)

compiler/daemon/src/org/jetbrains/kotlin/daemon/CompileServiceImpl.kt

@@ -426,7 +426,7 @@ class CompileServiceImpl(
             val bytesOut = ByteArrayOutputStream()
             val printStream = PrintStream(bytesOut)
             val mc = PrintingMessageCollector(printStream, MessageRenderer.PLAIN_FULL_PATHS, false)
-            val parsedModule = ModuleXmlParser.parseModuleScript(k2jvmArgs.buildFile, mc)
+            val parsedModule = ModuleXmlParser.parseModuleScript(k2jvmArgs.buildFile!!, mc)
             if (mc.hasErrors()) {
                 daemonMessageReporter.report(ReportSeverity.ERROR, bytesOut.toString("UTF8"))
             }

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt

@@ -104,7 +104,7 @@ class IncrementalJvmCompilerRunner(
             messageCollector: MessageCollector,
             getChangedFiles: (IncrementalCachesManager)->ChangedFiles
     ): ExitCode {
-        val targetId = TargetId(name = args.moduleName, type = "java-production")
+        val targetId = TargetId(name = args.moduleName!!, type = "java-production")
         var caches = IncrementalCachesManager(targetId, cacheDirectory, File(args.destination), reporter)
 
         fun onError(e: Exception): ExitCode {
@@ -411,7 +411,7 @@ class IncrementalJvmCompilerRunner(
         val compiler = K2JVMCompiler()
         val outputDir = args.destinationAsFile
         val classpath = args.classpathAsList
-        val moduleFile = makeModuleFile(args.moduleName,
+        val moduleFile = makeModuleFile(args.moduleName!!,
                 isTest = false,
                 outputDir = outputDir,
                 sourcesToCompile = sourcesToCompile,
@@ -472,5 +472,5 @@ var K2JVMCompilerArguments.destinationAsFile: File
         set(value) { destination = value.path }
 
 var K2JVMCompilerArguments.classpathAsList: List<File>
-    get() = classpath.split(File.pathSeparator).map(::File)
+    get() = classpath!!.split(File.pathSeparator).map(::File)
     set(value) { classpath = value.joinToString(separator = File.pathSeparator, transform = { it.path }) }

compiler/tests/org/jetbrains/kotlin/cli/FriendPathsTest.kt

@@ -56,7 +56,7 @@ class FriendPathsTest : TestCaseWithTmpdir() {
         return K2JVMCompiler().exec(ThrowingMessageCollector(), Services.EMPTY, K2JVMCompilerArguments().apply {
             destination = tmpdir.path
             classpath = libraryPath
-            freeArgs = listOf(File(getTestDataDirectory(), "usage.kt").path)
+            freeArgs = arrayListOf(File(getTestDataDirectory(), "usage.kt").path)
 
             friendPaths = arrayOf(libraryPath)
         })

idea/idea-jps-common/src/org/jetbrains/kotlin/config/facetSerialization.kt

@@ -137,7 +137,7 @@ fun deserializeFacetSettings(element: Element): KotlinFacetSettings {
 }
 
 fun CommonCompilerArguments.convertPathsToSystemIndependent() {
-    pluginClasspaths?.forEachIndexed { index, s -> pluginClasspaths[index] = PathUtil.toSystemIndependentName(s) }
+    pluginClasspaths?.forEachIndexed { index, s -> pluginClasspaths!![index] = PathUtil.toSystemIndependentName(s) }
 
     when (this) {
         is K2JVMCompilerArguments -> {
@@ -145,7 +145,7 @@ fun CommonCompilerArguments.convertPathsToSystemIndependent() {
             classpath = PathUtil.toSystemIndependentName(classpath)
             jdkHome = PathUtil.toSystemIndependentName(jdkHome)
             kotlinHome = PathUtil.toSystemIndependentName(kotlinHome)
-            friendPaths?.forEachIndexed { index, s -> friendPaths[index] = PathUtil.toSystemIndependentName(s) }
+            friendPaths?.forEachIndexed { index, s -> friendPaths!![index] = PathUtil.toSystemIndependentName(s) }
             declarationsOutputPath = PathUtil.toSystemIndependentName(declarationsOutputPath)
         }
 

idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/KotlinMavenImporterTest.kt

@@ -1348,7 +1348,7 @@ class KotlinMavenImporterTest : MavenImportingTestCase() {
                            "plugin:org.jetbrains.kotlin.allopen:annotation=org.springframework.transaction.annotation.Transactional",
                            "plugin:org.jetbrains.kotlin.allopen:annotation=org.springframework.scheduling.annotation.Async",
                            "plugin:org.jetbrains.kotlin.allopen:annotation=org.springframework.cache.annotation.Cacheable"),
-                    compilerArguments!!.pluginOptions.toList()
+                    compilerArguments!!.pluginOptions!!.toList()
             )
         }
     }

idea/src/org/jetbrains/kotlin/idea/compiler/configuration/KotlinCompilerConfigurableTab.java

@@ -428,9 +428,9 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
 
     @Override
     public boolean isModified() {
-        return ComparingUtils.isModified(reportWarningsCheckBox, !commonCompilerArguments.suppressWarnings) ||
+        return ComparingUtils.isModified(reportWarningsCheckBox, !commonCompilerArguments.getSuppressWarnings()) ||
-               !getSelectedLanguageVersion().equals(getLanguageVersionOrDefault(commonCompilerArguments.languageVersion)) ||
+               !getSelectedLanguageVersion().equals(getLanguageVersionOrDefault(commonCompilerArguments.getLanguageVersion())) ||
-               !getSelectedAPIVersion().equals(getApiVersionOrDefault(commonCompilerArguments.apiVersion)) ||
+               !getSelectedAPIVersion().equals(getApiVersionOrDefault(commonCompilerArguments.getApiVersion())) ||
                !coroutineSupportComboBox.getSelectedItem().equals(CoroutineSupport.byCompilerArguments(commonCompilerArguments)) ||
                ComparingUtils.isModified(additionalArgsOptionsField, compilerSettings.additionalArguments) ||
                ComparingUtils.isModified(scriptTemplatesField, compilerSettings.scriptTemplates) ||
@@ -442,14 +442,14 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
                 (ComparingUtils.isModified(enablePreciseIncrementalCheckBox, compilerWorkspaceSettings.getPreciseIncrementalEnabled()) ||
                  ComparingUtils.isModified(keepAliveCheckBox, compilerWorkspaceSettings.getEnableDaemon()))) ||
 
-               ComparingUtils.isModified(generateSourceMapsCheckBox, k2jsCompilerArguments.sourceMap) ||
+               ComparingUtils.isModified(generateSourceMapsCheckBox, k2jsCompilerArguments.getSourceMap()) ||
-               ComparingUtils.isModified(outputPrefixFile, k2jsCompilerArguments.outputPrefix) ||
+               ComparingUtils.isModified(outputPrefixFile, k2jsCompilerArguments.getOutputPrefix()) ||
-               ComparingUtils.isModified(outputPostfixFile, k2jsCompilerArguments.outputPostfix) ||
+               ComparingUtils.isModified(outputPostfixFile, k2jsCompilerArguments.getOutputPostfix()) ||
-               !getSelectedModuleKind().equals(getModuleKindOrDefault(k2jsCompilerArguments.moduleKind)) ||
+               !getSelectedModuleKind().equals(getModuleKindOrDefault(k2jsCompilerArguments.getModuleKind())) ||
-               ComparingUtils.isModified(sourceMapPrefix, k2jsCompilerArguments.sourceMapPrefix) ||
+               ComparingUtils.isModified(sourceMapPrefix, k2jsCompilerArguments.getSourceMapPrefix()) ||
                !getSelectedSourceMapSourceEmbedding().equals(
-                       getSourceMapSourceEmbeddingOrDefault(k2jsCompilerArguments.sourceMapEmbedSources)) ||
+                       getSourceMapSourceEmbeddingOrDefault(k2jsCompilerArguments.getSourceMapEmbedSources())) ||
-               !getSelectedJvmVersion().equals(getJvmVersionOrDefault(k2jvmCompilerArguments.jvmTarget));
+               !getSelectedJvmVersion().equals(getJvmVersionOrDefault(k2jvmCompilerArguments.getJvmTarget()));
     }
 
     @NotNull
@@ -486,8 +486,8 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
     ) throws ConfigurationException {
         if (isProjectSettings) {
             boolean shouldInvalidateCaches =
-                    commonCompilerArguments.languageVersion != getSelectedLanguageVersion().getVersionString() ||
+                    commonCompilerArguments.getLanguageVersion() != getSelectedLanguageVersion().getVersionString() ||
-                    commonCompilerArguments.apiVersion != getSelectedAPIVersion().getVersionString() ||
+                    commonCompilerArguments.getApiVersion() != getSelectedAPIVersion().getVersionString() ||
                     !coroutineSupportComboBox.getSelectedItem().equals(CoroutineSupport.byCompilerArguments(commonCompilerArguments));
 
             if (shouldInvalidateCaches) {
@@ -503,20 +503,20 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
             }
         }
 
-        commonCompilerArguments.suppressWarnings = !reportWarningsCheckBox.isSelected();
+        commonCompilerArguments.setSuppressWarnings(!reportWarningsCheckBox.isSelected());
-        commonCompilerArguments.languageVersion = getSelectedLanguageVersion().getVersionString();
+        commonCompilerArguments.setLanguageVersion(getSelectedLanguageVersion().getVersionString());
-        commonCompilerArguments.apiVersion = getSelectedAPIVersion().getVersionString();
+        commonCompilerArguments.setApiVersion(getSelectedAPIVersion().getVersionString());
 
         switch ((LanguageFeature.State) coroutineSupportComboBox.getSelectedItem()) {
             case ENABLED:
-                commonCompilerArguments.coroutinesState = CommonCompilerArguments.ENABLE;
+                commonCompilerArguments.setCoroutinesState(CommonCompilerArguments.ENABLE);
                 break;
             case ENABLED_WITH_WARNING:
-                commonCompilerArguments.coroutinesState = CommonCompilerArguments.WARN;
+                commonCompilerArguments.setCoroutinesState(CommonCompilerArguments.WARN);
                 break;
             case ENABLED_WITH_ERROR:
             case DISABLED:
-                commonCompilerArguments.coroutinesState = CommonCompilerArguments.ERROR;
+                commonCompilerArguments.setCoroutinesState(CommonCompilerArguments.ERROR);
                 break;
         }
 
@@ -536,15 +536,15 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
             }
         }
 
-        k2jsCompilerArguments.sourceMap = generateSourceMapsCheckBox.isSelected();
+        k2jsCompilerArguments.setSourceMap(generateSourceMapsCheckBox.isSelected());
-        k2jsCompilerArguments.outputPrefix = StringUtil.nullize(outputPrefixFile.getText(), true);
+        k2jsCompilerArguments.setOutputPrefix(StringUtil.nullize(outputPrefixFile.getText(), true));
-        k2jsCompilerArguments.outputPostfix = StringUtil.nullize(outputPostfixFile.getText(), true);
+        k2jsCompilerArguments.setOutputPostfix(StringUtil.nullize(outputPostfixFile.getText(), true));
-        k2jsCompilerArguments.moduleKind = getSelectedModuleKind();
+        k2jsCompilerArguments.setModuleKind(getSelectedModuleKind());
 
-        k2jsCompilerArguments.sourceMapPrefix = sourceMapPrefix.getText();
+        k2jsCompilerArguments.setSourceMapPrefix(sourceMapPrefix.getText());
-        k2jsCompilerArguments.sourceMapEmbedSources = getSelectedSourceMapSourceEmbedding();
+        k2jsCompilerArguments.setSourceMapEmbedSources(getSelectedSourceMapSourceEmbedding());
 
-        k2jvmCompilerArguments.jvmTarget = getSelectedJvmVersion();
+        k2jvmCompilerArguments.setJvmTarget(getSelectedJvmVersion());
 
         if (isProjectSettings) {
             KotlinCommonCompilerArgumentsHolder.Companion.getInstance(project).setSettings(commonCompilerArguments);
@@ -563,9 +563,9 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
 
     @Override
     public void reset() {
-        reportWarningsCheckBox.setSelected(!commonCompilerArguments.suppressWarnings);
+        reportWarningsCheckBox.setSelected(!commonCompilerArguments.getSuppressWarnings());
-        languageVersionComboBox.setSelectedItem(getLanguageVersionOrDefault(commonCompilerArguments.languageVersion));
+        languageVersionComboBox.setSelectedItem(getLanguageVersionOrDefault(commonCompilerArguments.getLanguageVersion()));
-        apiVersionComboBox.setSelectedItem(getApiVersionOrDefault(commonCompilerArguments.apiVersion));
+        apiVersionComboBox.setSelectedItem(getApiVersionOrDefault(commonCompilerArguments.getApiVersion()));
         restrictAPIVersions(getSelectedLanguageVersion());
         coroutineSupportComboBox.setSelectedItem(CoroutineSupport.byCompilerArguments(commonCompilerArguments));
         additionalArgsOptionsField.setText(compilerSettings.additionalArguments);
@@ -579,16 +579,16 @@ public class KotlinCompilerConfigurableTab implements SearchableConfigurable, Co
             keepAliveCheckBox.setSelected(compilerWorkspaceSettings.getEnableDaemon());
         }
 
-        generateSourceMapsCheckBox.setSelected(k2jsCompilerArguments.sourceMap);
+        generateSourceMapsCheckBox.setSelected(k2jsCompilerArguments.getSourceMap());
-        outputPrefixFile.setText(k2jsCompilerArguments.outputPrefix);
+        outputPrefixFile.setText(k2jsCompilerArguments.getOutputPrefix());
-        outputPostfixFile.setText(k2jsCompilerArguments.outputPostfix);
+        outputPostfixFile.setText(k2jsCompilerArguments.getOutputPostfix());
 
-        moduleKindComboBox.setSelectedItem(getModuleKindOrDefault(k2jsCompilerArguments.moduleKind));
+        moduleKindComboBox.setSelectedItem(getModuleKindOrDefault(k2jsCompilerArguments.getModuleKind()));
-        sourceMapPrefix.setText(k2jsCompilerArguments.sourceMapPrefix);
+        sourceMapPrefix.setText(k2jsCompilerArguments.getSourceMapPrefix());
-        sourceMapPrefix.setEnabled(k2jsCompilerArguments.sourceMap);
+        sourceMapPrefix.setEnabled(k2jsCompilerArguments.getSourceMap());
-        sourceMapEmbedSources.setSelectedItem(getSourceMapSourceEmbeddingOrDefault(k2jsCompilerArguments.sourceMapEmbedSources));
+        sourceMapEmbedSources.setSelectedItem(getSourceMapSourceEmbeddingOrDefault(k2jsCompilerArguments.getSourceMapEmbedSources()));
 
-        jvmVersionComboBox.setSelectedItem(getJvmVersionOrDefault(k2jvmCompilerArguments.jvmTarget));
+        jvmVersionComboBox.setSelectedItem(getJvmVersionOrDefault(k2jvmCompilerArguments.getJvmTarget()));
     }
 
     @Override

idea/src/org/jetbrains/kotlin/idea/quickfix/EnableUnsupportedFeatureFix.kt

@@ -155,7 +155,7 @@ sealed class EnableUnsupportedFeatureFix(
             val targetVersion = feature.sinceVersion!!
 
             KotlinCommonCompilerArgumentsHolder.getInstance(project).update {
-                val parsedApiVersion = ApiVersion.parse(apiVersion)
+                val parsedApiVersion = ApiVersion.parse(apiVersion!!)
                 if (parsedApiVersion != null && feature.sinceApiVersion > parsedApiVersion) {
                     if (!checkUpdateRuntime(project, feature.sinceApiVersion)) return@update
                     apiVersion = feature.sinceApiVersion.versionString

idea/tests/org/jetbrains/kotlin/idea/codeInsight/gradle/GradleFacetImportTest.kt

@@ -866,7 +866,7 @@ compileTestKotlin {
                            "plugin:org.jetbrains.kotlin.allopen:annotation=org.springframework.transaction.annotation.Transactional",
                            "plugin:org.jetbrains.kotlin.allopen:annotation=org.springframework.scheduling.annotation.Async",
                            "plugin:org.jetbrains.kotlin.allopen:annotation=org.springframework.cache.annotation.Cacheable"),
-                    compilerArguments!!.pluginOptions.toList()
+                    compilerArguments!!.pluginOptions!!.toList()
             )
         }
     }

idea/tests/org/jetbrains/kotlin/idea/configuration/ConfigureKotlinTest.java

@@ -169,10 +169,10 @@ public class ConfigureKotlinTest extends AbstractConfigureKotlinTest {
         assertEquals("1.1", settings.getLanguageLevel().getDescription());
         assertEquals("1.0", settings.getApiLevel().getDescription());
         assertEquals(TargetPlatformKind.Jvm.Companion.get(JvmTarget.JVM_1_8), settings.getTargetPlatformKind());
-        assertEquals("1.1", arguments.languageVersion);
+        assertEquals("1.1", arguments.getLanguageVersion());
-        assertEquals("1.0", arguments.apiVersion);
+        assertEquals("1.0", arguments.getApiVersion());
         assertEquals(LanguageFeature.State.ENABLED_WITH_WARNING, CoroutineSupport.byCompilerArguments(arguments));
-        assertEquals("1.7", arguments.jvmTarget);
+        assertEquals("1.7", arguments.getJvmTarget());
         assertEquals("-version -Xallow-kotlin-package -Xskip-metadata-version-check", settings.getCompilerSettings().additionalArguments);
     }
 
@@ -184,10 +184,10 @@ public class ConfigureKotlinTest extends AbstractConfigureKotlinTest {
         assertEquals("1.1", settings.getLanguageLevel().getDescription());
         assertEquals("1.0", settings.getApiLevel().getDescription());
         assertEquals(TargetPlatformKind.JavaScript.INSTANCE, settings.getTargetPlatformKind());
-        assertEquals("1.1", arguments.languageVersion);
+        assertEquals("1.1", arguments.getLanguageVersion());
-        assertEquals("1.0", arguments.apiVersion);
+        assertEquals("1.0", arguments.getApiVersion());
         assertEquals(LanguageFeature.State.ENABLED_WITH_WARNING, CoroutineSupport.byCompilerArguments(arguments));
-        assertEquals("amd", arguments.moduleKind);
+        assertEquals("amd", arguments.getModuleKind());
         assertEquals("-version -meta-info", settings.getCompilerSettings().additionalArguments);
     }
 
@@ -199,10 +199,10 @@ public class ConfigureKotlinTest extends AbstractConfigureKotlinTest {
         assertEquals("1.1", settings.getLanguageLevel().getDescription());
         assertEquals("1.0", settings.getApiLevel().getDescription());
         assertEquals(TargetPlatformKind.Jvm.Companion.get(JvmTarget.JVM_1_8), settings.getTargetPlatformKind());
-        assertEquals("1.1", arguments.languageVersion);
+        assertEquals("1.1", arguments.getLanguageVersion());
-        assertEquals("1.0", arguments.apiVersion);
+        assertEquals("1.0", arguments.getApiVersion());
         assertEquals(LanguageFeature.State.ENABLED, CoroutineSupport.byCompilerArguments(arguments));
-        assertEquals("1.7", arguments.jvmTarget);
+        assertEquals("1.7", arguments.getJvmTarget());
         assertEquals("-version -Xallow-kotlin-package -Xskip-metadata-version-check", settings.getCompilerSettings().additionalArguments);
     }
 
@@ -214,10 +214,10 @@ public class ConfigureKotlinTest extends AbstractConfigureKotlinTest {
         assertEquals("1.1", settings.getLanguageLevel().getDescription());
         assertEquals("1.0", settings.getApiLevel().getDescription());
         assertEquals(TargetPlatformKind.JavaScript.INSTANCE, settings.getTargetPlatformKind());
-        assertEquals("1.1", arguments.languageVersion);
+        assertEquals("1.1", arguments.getLanguageVersion());
-        assertEquals("1.0", arguments.apiVersion);
+        assertEquals("1.0", arguments.getApiVersion());
         assertEquals(LanguageFeature.State.ENABLED_WITH_ERROR, CoroutineSupport.byCompilerArguments(arguments));
-        assertEquals("amd", arguments.moduleKind);
+        assertEquals("amd", arguments.getModuleKind());
         assertEquals("-version -meta-info", settings.getCompilerSettings().additionalArguments);
     }
 
@@ -229,10 +229,10 @@ public class ConfigureKotlinTest extends AbstractConfigureKotlinTest {
         assertEquals("1.1", settings.getLanguageLevel().getDescription());
         assertEquals("1.0", settings.getApiLevel().getDescription());
         assertEquals(TargetPlatformKind.Jvm.Companion.get(JvmTarget.JVM_1_8), settings.getTargetPlatformKind());
-        assertEquals("1.1", arguments.languageVersion);
+        assertEquals("1.1", arguments.getLanguageVersion());
-        assertEquals("1.0", arguments.apiVersion);
+        assertEquals("1.0", arguments.getApiVersion());
         assertEquals(LanguageFeature.State.ENABLED, CoroutineSupport.byCompilerArguments(arguments));
-        assertEquals("1.7", arguments.jvmTarget);
+        assertEquals("1.7", arguments.getJvmTarget());
         assertEquals("-version -Xallow-kotlin-package -Xskip-metadata-version-check", settings.getCompilerSettings().additionalArguments);
     }
 
@@ -249,7 +249,8 @@ public class ConfigureKotlinTest extends AbstractConfigureKotlinTest {
                     modelsProvider
             );
             assertEquals(platformKind, facet.getConfiguration().getSettings().getTargetPlatformKind());
-            assertEquals(jvmTarget.getDescription(), ((K2JVMCompilerArguments) facet.getConfiguration().getSettings().getCompilerArguments()).jvmTarget);
+            assertEquals(jvmTarget.getDescription(),
+                         ((K2JVMCompilerArguments) facet.getConfiguration().getSettings().getCompilerArguments()).getJvmTarget());
         }
         finally {
             modelsProvider.dispose();