Ensured all missing Kolin compiler arguments are handled

scripts/checkcliargs.sh

@@ -5,12 +5,19 @@ new=/tmp/checkcliargs-new
 old=/tmp/checkcliargs-old
 
 java -cp "lib/compile/*" $main -h >$new
-java -cp "/examples/lib/bld*" $main -h >$old
+java -cp "examples/lib/bld/*" $main -h >$old
 
 diff $old $new
 
 java -cp "lib/compile/*" $main -sourceSet -h >$new
-java -cp "/examples/lib/bld*" $main -sourceSet -h >$old
+java -cp "examples/lib/bld/*" $main -sourceSet -h >$old
+
+diff $old $new
+
+main=org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
+
+java -cp "lib/compile/*" $main -h 2>$new
+java -cp "examples/lib/bld/*" $main -h 2>$old
 
 diff $old $new
 

scripts/cliargs.sh

@@ -1,5 +1,9 @@
 #!/bin/bash
 
+java -cp "lib/compile/*" org.jetbrains.kotlin.cli.jvm.K2JVMCompiler -h 2> >(grep "^  ") |\
+sed -e "s/^  //" -e "s/ .*//" -e "s/<.*//" -e '/-help/d' -e '/-version/d' -e '/^$/d'|\
+sort > "src/test/resources/kotlinc-args.txt"
+
 main=org.jetbrains.dokka.MainKt
 
 java -cp "lib/compile/*" $main -h |\

src/bld/java/rife/bld/extension/CompileKotlinOperationBuild.java

@@ -98,15 +98,6 @@ public class CompileKotlinOperationBuild extends Project {
         new CompileKotlinOperationBuild().start(args);
     }
 
-    @Override
-    public void test() throws Exception {
-        new ExecOperation()
-                .fromProject(this)
-                .command("scripts/cliargs.sh")
-                .execute();
-        super.test();
-    }
-
     @BuildCommand(summary = "Runs PMD analysis")
     public void pmd() {
         new PmdOperation()
@@ -115,4 +106,13 @@ public class CompileKotlinOperationBuild extends Project {
                 .ruleSets("config/pmd.xml")
                 .execute();
     }
+
+    @Override
+    public void test() throws Exception {
+        new ExecOperation()
+                .fromProject(this)
+                .command("scripts/cliargs.sh")
+                .execute();
+        super.test();
+    }
 }

src/main/java/rife/bld/extension/CompileKotlinOptions.java

@@ -31,13 +31,16 @@ import static rife.bld.extension.CompileKotlinOperation.isNotBlank;
  * @since 1.0
  */
 public class CompileKotlinOptions {
+    private final List<String> advancedOptions_ = new ArrayList<>();
     private final List<String> argFile_ = new ArrayList<>();
     private final List<String> classpath_ = new ArrayList<>();
+    private final List<String> jvmOptions_ = new ArrayList<>();
     private final List<String> optIn_ = new ArrayList<>();
     private final List<String> options_ = new ArrayList<>();
     private final List<String> plugin_ = new ArrayList<>();
     private final List<String> scriptTemplates_ = new ArrayList<>();
     private String apiVersion_;
+    private String expression_;
     private boolean includeRuntime_;
     private boolean javaParameters_;
     private String jdkHome_;
@@ -55,6 +58,28 @@ public class CompileKotlinOptions {
     private boolean verbose_;
     private boolean wError_;
 
+    /**
+     * Specify advanced compiler options.
+     *
+     * @param options one or more advanced options
+     * @return this operation instance
+     */
+    public CompileKotlinOptions advancedOptions(String... options) {
+        Collections.addAll(advancedOptions_, options);
+        return this;
+    }
+
+    /**
+     * Specify advanced compiler options.
+     *
+     * @param options list of compiler options
+     * @return this operation instance
+     */
+    public CompileKotlinOptions advancedOptions(Collection<String> options) {
+        advancedOptions_.addAll(options);
+        return this;
+    }
+
     /**
      * Allow using declarations only from the specified version of Kotlin bundled libraries.
      *
@@ -120,7 +145,7 @@ public class CompileKotlinOptions {
     public List<String> args() {
         var args = new ArrayList<String>();
 
-        // api-isNotBlankversion
+        // api-version
         if (isNotBlank(apiVersion_)) {
             args.add("-api-version");
             args.add(apiVersion_);
@@ -137,6 +162,12 @@ public class CompileKotlinOptions {
             args.add(String.join(File.pathSeparator, classpath_));
         }
 
+        // expression
+        if (isNotBlank(expression_)) {
+            args.add("-expression");
+            args.add(expression_);
+        }
+
         // java-parameters
         if (javaParameters_) {
             args.add("-java-parameters");
@@ -164,6 +195,11 @@ public class CompileKotlinOptions {
             args.add("-Xjdk-release=" + jdkRelease_);
         }
 
+        // JVM options
+        if (!jvmOptions_.isEmpty()) {
+            jvmOptions_.forEach(s -> args.add("-J" + s));
+        }
+
         // kotlin-home
         if (isNotBlank(kotlinHome_)) {
             args.add("-kotlin-home");
@@ -199,7 +235,7 @@ public class CompileKotlinOptions {
 
         // no-warn
         if (noWarn_) {
-            args.add("-no-warn");
+            args.add("-nowarn");
         }
 
         // opt-in
@@ -246,6 +282,11 @@ public class CompileKotlinOptions {
             args.add("-Werror");
         }
 
+        // advanced option (X)
+        if (!advancedOptions_.isEmpty()) {
+            advancedOptions_.forEach(it -> args.add("-X" + it));
+        }
+
         return args;
     }
 
@@ -275,6 +316,17 @@ public class CompileKotlinOptions {
         return this;
     }
 
+    /**
+     * Evaluate the given string as a Kotlin script.
+     *
+     * @param expression the expression
+     * @return this operation instance
+     */
+    public CompileKotlinOptions expression(String expression) {
+        expression_ = expression;
+        return this;
+    }
+
     /**
      * Indicates whether the {@link #jdkRelease(String) jdkRelease} was set.
      *
@@ -346,6 +398,28 @@ public class CompileKotlinOptions {
         return this;
     }
 
+    /**
+     * Pass an option directly to JVM
+     *
+     * @param jvmOptions one or more JVM option
+     * @return this operation instance
+     */
+    public CompileKotlinOptions jvmOptions(String... jvmOptions) {
+        Collections.addAll(jvmOptions_, jvmOptions);
+        return this;
+    }
+
+    /**
+     * Pass an option directly to JVM
+     *
+     * @param jvmOptions the list JVM options
+     * @return this operation instance
+     */
+    public CompileKotlinOptions jvmOptions(Collection<String> jvmOptions) {
+        jvmOptions_.addAll(jvmOptions);
+        return this;
+    }
+
     /**
      * Specify the target version of the generated JVM bytecode.
      * <p>

src/test/java/rife/bld/extension/CompileKotlinOptionsTest.java

@@ -19,6 +19,9 @@ package rife.bld.extension;
 import org.junit.jupiter.api.Test;
 
 import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.IntStream;
@@ -30,8 +33,10 @@ class CompileKotlinOptionsTest {
     @Test
     void argsCollectionTest() {
         var args = new CompileKotlinOptions()
+                .advancedOptions(List.of("Xoption1", "Xoption2"))
                 .argFile(List.of("arg1.txt", "arg2.txt"))
                 .classpath(List.of("path1", "path2"))
+                .jvmOptions(List.of("option1", "option2"))
                 .noStdLib(false)
                 .optIn(List.of("opt1", "opt2"))
                 .options(List.of("-foo", "-bar"))
@@ -40,18 +45,26 @@ class CompileKotlinOptionsTest {
         var matches = List.of(
                 "@arg1.txt", "@arg2.txt",
                 "-classpath", "path1:path2",
+                "-Joption1", "-Joption2",
                 "-opt-in", "opt1",
                 "-opt-in", "opt2",
-                "-foo",
+                "-foo", "-bar",
-                "-bar",
+                "-script-templates",
-                "-script-templates", "temp1,temp2");
+                "temp1,temp2",
-
+                "-XXoption1", "-XXoption2");
-        assertThat(args).hasSize(matches.size());
-
-        IntStream.range(0, args.size()).forEach(i -> assertThat(args.get(i)).isEqualTo(matches.get(i)));
-
 
+        for (var arg : args) {
+            var found = false;
+            for (var match : matches) {
+                if (match.equals(arg)) {
+                    found = true;
+                    break;
                 }
+            }
+            assertThat(found).as(arg).isTrue();
+        }
+    }
+
 
     @Test
     void argsTest() {
@@ -93,7 +106,7 @@ class CompileKotlinOptionsTest {
                 "-module-name", "module",
                 "-no-jdk",
                 "-no-reflect",
-                "-no-warn",
+                "-nowarn",
                 "-opt-in", "opt1",
                 "-opt-in", "opt2",
                 "-foo",
@@ -114,4 +127,47 @@ class CompileKotlinOptionsTest {
             IntStream.range(0, a.size()).forEach(i -> assertThat(a.get(i)).isEqualTo(matches.get(i)));
         }
     }
+
+    @Test
+    void checkAllParamsTest() throws IOException {
+        var args = Files.readAllLines(Paths.get("src", "test", "resources", "kotlinc-args.txt"));
+
+        assertThat(args).isNotEmpty();
+
+        var params = new CompileKotlinOptions()
+                .advancedOptions("Xoption")
+                .argFile("file")
+                .classpath("classpath")
+                .expression("expression")
+                .jvmOptions("option")
+                .includeRuntime(true)
+                .javaParameters(true)
+                .jdkHome("jdkhome")
+                .jvmTarget(12)
+                .kotlinHome("kotlin")
+                .moduleName("moduleName")
+                .noJdk(true)
+                .noReflect(true)
+                .noStdLib(true)
+                .noWarn(true)
+                .optIn("annotation")
+                .options("option")
+                .path("path")
+                .plugin("id", "option", "value")
+                .progressive(true)
+                .scriptTemplates("template")
+                .verbose(true)
+                .wError(true);
+
+        for (var p : args) {
+            var found = false;
+            for (var a : params.args()) {
+                if (a.startsWith(p)) {
+                    found = true;
+                    break;
+                }
+            }
+            assertThat(found).as(p + " not found.").isTrue();
+        }
+    }
 }

src/test/java/rife/bld/extension/dokka/DokkaOperationTest.java

@@ -34,13 +34,13 @@ class DokkaOperationTest {
     @Test
     @SuppressWarnings({"ExtractMethodRecommender", "PMD.AvoidDuplicateLiterals"})
     void executeConstructProcessCommandListTest() throws IOException {
-        var params = Files.readAllLines(Paths.get("src", "test", "resources", "dokka-args.txt"));
+        var args = Files.readAllLines(Paths.get("src", "test", "resources", "dokka-args.txt"));
 
-        assertThat(params).isNotEmpty();
+        assertThat(args).isNotEmpty();
 
         var examples = new File("examples");
         var jsonConf = new File("config.json");
-        var args = new DokkaOperation()
+        var params = new DokkaOperation()
                 .delayTemplateSubstitution(true)
                 .failOnWarning(true)
                 .fromProject(new BaseProjectBlueprint(examples, "com.example", "Example"))
@@ -72,9 +72,9 @@ class DokkaOperationTest {
                 .suppressInheritedMembers(true)
                 .executeConstructProcessCommandList();
 
-        for (var p : params) {
+        for (var p : args) {
             var found = false;
-            for (var a : args) {
+            for (var a : params) {
                 if (a.startsWith(p)) {
                     found = true;
                     break;
@@ -109,14 +109,14 @@ class DokkaOperationTest {
                 "-suppressInheritedMembers",
                 jsonConf.getAbsolutePath());
 
-        assertThat(args).hasSize(matches.size());
+        assertThat(params).hasSize(matches.size());
 
-        IntStream.range(0, args.size()).forEach(i -> {
+        IntStream.range(0, params.size()).forEach(i -> {
-            if (args.get(i).contains(".jar;")) {
+            if (params.get(i).contains(".jar;")) {
-                var jars = args.get(i).split(";");
+                var jars = params.get(i).split(";");
                 Arrays.stream(jars).forEach(jar -> assertThat(matches.get(i)).as(matches.get(i)).contains(jar));
             } else {
-                assertThat(args.get(i)).as(args.get(i)).isEqualTo(matches.get(i));
+                assertThat(params.get(i)).as(params.get(i)).isEqualTo(matches.get(i));
             }
         });
     }

src/test/resources/kotlinc-args.txt

@@ -0,0 +1,23 @@
+@
+-classpath
+-d
+-expression
+-include-runtime
+-J
+-java-parameters
+-jdk-home
+-jvm-target
+-kotlin-home
+-module-name
+-no-jdk
+-no-reflect
+-no-stdlib
+-nowarn
+-opt-in
+-P
+-progressive
+-script
+-script-templates
+-verbose
+-Werror
+-X