3-stage compile to support Groovy <-> Java cycles

Author: lostiniceland

libs/groovylib/api/src/mill/groovylib/worker/api/GroovyWorker.scala

@@ -4,9 +4,34 @@ import mill.api.TaskCtx
 import mill.api.Result
 import mill.javalib.api.CompilationResult
 
+/**
+ * Runs the actual compilation.
+ *
+ * Supports 3-stage compilation for Java <-> Groovy
+ * 1. compile Java stubs
+ * 2. compile Java sources (done externally)
+ * 3. compile Groovy sources
+ */
 trait GroovyWorker {
 
+  /**
+   * In a mixed setup this will compile the Groovy sources to Java stubs.
+   */
+  def compileGroovyStubs(
+      sourceFiles: Seq[os.Path],
+      classpath: Seq[os.Path],
+      outputDir: os.Path
+  )(implicit
+      ctx: TaskCtx
+  )
+      : Result[CompilationResult]
+
+  /**
+   * Compiles the Groovy sources. In a mixed setup this method assumes that the Java stubs
+   * are already present in the outputDir.
+   */
   def compile(sourceFiles: Seq[os.Path], classpath: Seq[os.Path], outputDir: os.Path)(implicit
       ctx: TaskCtx
-  ): Result[CompilationResult]
+  )
+      : Result[CompilationResult]
 }

libs/groovylib/package.mill

@@ -8,7 +8,7 @@ import millbuild.*
 object `package` extends MillPublishScalaModule with BuildInfo {
 
   def moduleDeps = Seq(build.libs.javalib, build.libs.javalib.testrunner, api)
-  def localTestExtraModules =
+  def localTestExtraModules: Seq[MillJavaModule] =
     super.localTestExtraModules ++ Seq(worker)
 
   def buildInfoPackageName = "mill.groovylib"

libs/groovylib/src/mill/groovylib/GroovyModule.scala

@@ -12,7 +12,9 @@ import mill.api.daemon.internal.bsp.{BspBuildTarget, BspModuleApi}
 import mill.javalib.api.internal.{JavaCompilerOptions, JvmWorkerApi, ZincCompileJava}
 
 /**
- * Core configuration required to compile a single Groovy module
+ * Core configuration required to compile a single Groovy module.
+ *
+ * Resolves
  */
 trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
 
@@ -33,36 +35,31 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
    * All individual source files fed into the compiler.
    */
   override def allSourceFiles: T[Seq[PathRef]] = Task {
-    Lib.findSourceFiles(allSources(), Seq("groovy", "java")).map(PathRef(_))
+    allGroovySourceFiles() ++ allJavaSourceFiles()
   }
 
   /**
    * All individual Java source files fed into the compiler.
    * Subset of [[allSourceFiles]].
    */
   private def allJavaSourceFiles: T[Seq[PathRef]] = Task {
-    allSourceFiles().filter(_.path.ext.toLowerCase() == "java")
+    Lib.findSourceFiles(allSources(), Seq("java")).map(PathRef(_))
   }
 
   /**
    * All individual Groovy source files fed into the compiler.
    * Subset of [[allSourceFiles]].
    */
   private def allGroovySourceFiles: T[Seq[PathRef]] = Task {
-    allSourceFiles().filter(path => Seq("groovy").contains(path.path.ext.toLowerCase()))
+    Lib.findSourceFiles(allSources(), Seq("groovy")).map(PathRef(_))
   }
 
   /**
    * The dependencies of this module.
-   * Defaults to add the groovy dependency matching the [[groovyVersion]].
+   * Defaults to add the Groovy dependency matching the [[groovyVersion]].
    */
   override def mandatoryMvnDeps: T[Seq[Dep]] = Task {
-    super.mandatoryMvnDeps()
-    ++
-      groovyCompilerMvnDeps()
-//    Seq(
-//      mvn"org.apache.groovy:groovy:${groovyVersion()}"
-//    )
+    super.mandatoryMvnDeps() ++ groovyCompilerMvnDeps()
   }
 
   def jvmWorkerRef: ModuleRef[JvmWorkerModule] = jvmWorker
@@ -86,31 +83,11 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
   /**
    * The Ivy/Coursier dependencies resembling the Groovy compiler.
    *
-   * Default is derived from [[groovyCompilerVersion]].
+   * Default is derived from [[groovyVersion]].
    */
   def groovyCompilerMvnDeps: T[Seq[Dep]] = Task {
     val gv = groovyVersion()
-
-    val compilerDep = mvn"org.apache.groovy:groovy-all:$gv"
-//    val annotationDep = mvn"org.codehaus.groovy:groovy-all-annotations:$gv"
-
-    Seq(compilerDep)
-  }
-
-  /**
-   * Compiler Plugin dependencies.
-   */
-  def groovyCompilerPluginMvnDeps: T[Seq[Dep]] = Task { Seq.empty[Dep] }
-
-  /**
-   * The resolved plugin jars
-   */
-  def groovyCompilerPluginJars: T[Seq[PathRef]] = Task {
-    val jars = defaultResolver().classpath(
-      allMvnDeps(),
-      resolutionParamsMapOpt = None
-    )
-    jars.toSeq
+    Seq(mvn"org.apache.groovy:groovy:$gv")
   }
 
   /**
@@ -121,9 +98,8 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
   }
 
   /**
-   * The actual Groovy compile task (used by [[compile]] and [[groovycHelp]]).
+   * The actual Groovy compile task (used by [[compile]]).
    */
-  // TODO joint compilation: generate groovy-stubs -> compile java -> compile groovy -> delete stubs (or keep for debugging)
   protected def groovyCompileTask(): Task[CompilationResult] =
     Task.Anon {
       val ctx = Task.ctx()
@@ -143,9 +119,9 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
 
       def compileJava: Result[CompilationResult] = {
         ctx.log.info(
-          s"Compiling ${javaSourceFiles.size} Java sources to ${classes} ..."
+          s"Compiling ${javaSourceFiles.size} Java sources to $classes ..."
         )
-        // The compile step is lazy, but its dependencies are not!
+        // The compiler step is lazy, but its dependencies are not!
         internalCompileJavaFiles(
           worker = jvmWorkerRef().internalWorker(),
           upstreamCompileOutput = updateCompileOutput,
@@ -158,40 +134,43 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
         )
       }
 
+      if (isMixed) {
+        ctx.log.info("Compiling Groovy stubs for mixed compilation")
+
+        val workerStubResult =
+          GroovyWorkerManager.groovyWorker().withValue(groovyCompilerClasspath()) {
+            _.compileGroovyStubs(groovySourceFiles, compileCp, classes)
+          }
+        workerStubResult match {
+          case Result.Success(_) => compileJava
+          case Result.Failure(reason) => Result.Failure(reason)
+        }
+      }
+
       if (isMixed || isGroovy) {
         ctx.log.info(
-          s"Compiling ${groovySourceFiles.size} Groovy sources to ${classes} ..."
+          s"Compiling ${groovySourceFiles.size} Groovy sources to $classes ..."
         )
 
-        val compileCp = compileClasspath().map(_.path).filter(os.exists)
-
-        val workerResult =
+        val workerGroovyResult =
           GroovyWorkerManager.groovyWorker().withValue(groovyCompilerClasspath()) {
             _.compile(groovySourceFiles, compileCp, classes)
           }
 
+        // TODO figure out if there is a better way to do this
         val analysisFile = dest / "groovy.analysis.dummy" // needed for mills CompilationResult
         os.write(target = analysisFile, data = "", createFolders = true)
 
-        workerResult match {
+        workerGroovyResult match {
           case Result.Success(_) =>
-            val cr = CompilationResult(analysisFile, PathRef(classes))
-            if (!isJava) {
-              // pure Groovy project
-              cr
-            } else {
-              // also run Java compiler and use it's returned result
-              compileJava
-            }
+            CompilationResult(analysisFile, PathRef(classes))
           case Result.Failure(reason) => Result.Failure(reason)
         }
       } else {
-        // it's Java only
         compileJava
       }
     }
 
-
   private[groovylib] def internalCompileJavaFiles(
       worker: JvmWorkerApi,
       upstreamCompileOutput: Seq[CompilationResult],
@@ -236,7 +215,7 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
   }
 
   /**
-   * A test sub-module linked to its parent module best suited for unit-tests.
+   * A test submodule linked to its parent module best suited for unit-tests.
    */
   trait GroovyTests extends JavaTests with GroovyModule {
 

libs/groovylib/test/resources/hello-groovy/groovy-tests/src/test/groovy/HelloMavenTestOnly.groovy

@@ -0,0 +1,12 @@
+package hello.maven.tests
+
+//import hello.Hello
+import org.junit.jupiter.api.Test
+import static org.junit.jupiter.api.Assertions.assertEquals
+
+class HelloMavenTestOnly {
+    @Test
+    void testSuccess() {
+        assertEquals(true, true)
+    }
+}

libs/groovylib/test/src/mill/groovylib/HelloGroovyTests.scala

@@ -1,8 +1,8 @@
 package mill
 package groovylib
 
-import mill.javalib.{JavaModule, MavenModule, TestModule}
-import mill.api.{ExecResult, Task}
+import mill.javalib.{JavaModule, TestModule}
+import mill.api.{Task}
 import mill.api.Discover
 import mill.testkit.{TestRootModule, UnitTester}
 import utest.*
@@ -17,12 +17,12 @@ object HelloGroovyTests extends TestSuite {
     lazy val millDiscover = Discover[this.type]
 
     // needed for a special test where only the tests are written in Groovy while appcode remains Java
-    object `mixed-compile` extends JavaModule with MavenModule {
+    object `groovy-tests` extends JavaMavenModuleWithGroovyTests {
 
-      object `test` extends TestGroovyMavenModule with TestModule.Junit5 {
+      object `test` extends GroovyMavenTests with TestModule.Junit5 {
 
         override def moduleDeps: Seq[JavaModule] = Seq(
-          HelloGroovy.`mixed-compile`, // TODO improve: TestOnly does not inherit outer deps
+          HelloGroovy.`groovy-tests`
         )
 
         override def groovyVersion = groovy4Version
@@ -37,6 +37,7 @@ object HelloGroovyTests extends TestSuite {
 
     object `joint-compile` extends GroovyModule {
       override def groovyVersion: T[String] = groovy4Version
+      override def mainClass = Some("jointcompile.JavaMain")
     }
 
     trait Test extends GroovyModule {
@@ -61,20 +62,16 @@ object HelloGroovyTests extends TestSuite {
         override def mainClass = Some("hellostatic.HelloStatic")
       }
 
-      object spock extends GroovyTests with TestModule.Junit5 {
+      object spock extends GroovyTests with TestModule.Spock {
         override def junitPlatformVersion = "1.13.4"
-        def spockVersion: T[String] = "2.3-groovy-4.0"
+        override def spockVersion = "2.3-groovy-4.0"
         override def groovyVersion = "4.0.28"
 
         def bomMvnDeps = Seq(
           mvn"org.junit:junit-bom:5.13.4",
-          mvn"org.apache.groovy:groovy-bom:${groovyVersion()}",
+//          mvn"org.apache.groovy:groovy-bom:${groovyVersion()}",
           mvn"org.spockframework:spock-bom:${spockVersion()}"
         )
-
-        def mvnDeps = Seq(
-          mvn"org.spockframework:spock-core"
-        )
       }
     }
     object main extends Test {
@@ -92,7 +89,14 @@ object HelloGroovyTests extends TestSuite {
   def tests: Tests = Tests {
 
     def m = HelloGroovy.main
-    def mixed = HelloGroovy.`mixed-compile`
+    def mixed = HelloGroovy.`groovy-tests`
+    def joint = HelloGroovy.`joint-compile`
+
+    test("running a Groovy script") {
+      testEval().scoped { eval =>
+        val Right(_) = eval.apply(m.script.run()): @unchecked
+      }
+    }
 
     test("running a Groovy script") {
       testEval().scoped { eval =>
@@ -128,7 +132,7 @@ object HelloGroovyTests extends TestSuite {
       }
     }
 
-    test("compiling & running a statically compiled Groovy") {
+    test("compile & run a statically compiled Groovy") {
       testEval().scoped { eval =>
         val Right(result) = eval.apply(m.staticcompile.compile): @unchecked
         assert(
@@ -138,17 +142,12 @@ object HelloGroovyTests extends TestSuite {
       }
     }
 
-    test("compile & run test-only Maven JUnit5 test") {
+    test("compile & test module (only test uses Groovy)") {
       testEval().scoped { eval =>
 
-        val Right(resultCompile) = eval.apply(mixed.compile): @unchecked
-        assert(
-          os.walk(resultCompile.value.classes.path).exists(_.last == "Greeter.class")
-        )
-
         val Right(_) = eval.apply(mixed.test.compile): @unchecked
         val Right(discovered) = eval.apply(mixed.test.discoveredTestClasses): @unchecked
-        assert(discovered.value == Seq("tests.GreeterTests"))
+        assert(discovered.value == Seq("hello.maven.tests.HelloMavenTestOnly"))
 
         val Right(_) = eval.apply(mixed.test.testForked()): @unchecked
       }
@@ -169,7 +168,20 @@ object HelloGroovyTests extends TestSuite {
       }
     }
 
+    test("compile joint (groovy <-> java cycle) & run") {
+      testEval().scoped { eval =>
+        val Right(result) = eval.apply(joint.compile): @unchecked
 
+        assert(
+          os.walk(result.value.classes.path).exists(_.last == "JavaPrinter.class")
+        )
+        assert(
+          os.walk(result.value.classes.path).exists(_.last == "GroovyGreeter.class")
+        )
+
+        val Right(_) = eval.apply(joint.run()): @unchecked
+      }
+    }
 
   }
 }