use Mill caching for stub folder

Author: lostiniceland

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

@@ -1,6 +1,6 @@
 package mill.groovylib.worker.api
 
-import mill.api.{Result, TaskCtx}
+import mill.api.{PathRef, Result, TaskCtx}
 import mill.javalib.api.CompilationResult
 
 /**
@@ -25,7 +25,7 @@ trait GroovyWorker {
   )(implicit
       ctx: TaskCtx
   )
-      : Result[CompilationResult]
+  : Result[Unit]
 
   /**
    * Compiles the Groovy sources. In a mixed setup this method assumes that the Java stubs

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

@@ -132,6 +132,29 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
     groovyCompileTask()()
   }
 
+  def compileGroovyStubs: T[Result[Unit]] = Task(persistent = true){
+    val groovySourceFiles = allGroovySourceFiles().map(_.path)
+    val stubDir = compileGeneratedGroovyStubs()
+    Task.ctx().log.info(s"Generating Java stubs for ${groovySourceFiles.size} Groovy sources to $stubDir ...")
+
+    val compileCp = compileClasspath().map(_.path).filter(os.exists)
+    val config = GroovyCompilerConfiguration(
+      enablePreview = groovyCompileEnablePreview(),
+      targetBytecode = groovyCompileTargetBytecode(),
+      disabledGlobalAstTransformations = disabledGlobalAstTransformations()
+    )
+
+    GroovyWorkerManager.groovyWorker().withValue(groovyCompilerClasspath()) {
+      _.compileGroovyStubs(groovySourceFiles, compileCp, stubDir, config)
+    }
+  }
+
+  /**
+   * Path to Java stub sources as part of the `compile` step. Stubs are generated
+   * by the Groovy compiler and later used by the Java compiler.
+   */
+  def compileGeneratedGroovyStubs: T[os.Path] = Task(persistent = true) { Task.dest }
+
   /**
    * The actual Groovy compile task (used by [[compile]]).
    */
@@ -147,11 +170,21 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
 
       val isGroovy = groovySourceFiles.nonEmpty
       val isJava = javaSourceFiles.nonEmpty
-      val isMixed = isGroovy && isJava
-
       val compileCp = compileClasspath().map(_.path).filter(os.exists)
       val updateCompileOutput = upstreamCompileOutput()
 
+      sealed trait CompilationStrategy
+      case object JavaOnly extends CompilationStrategy
+      case object GroovyOnly extends CompilationStrategy
+      case object Mixed extends CompilationStrategy
+
+      val strategy: CompilationStrategy = (isJava, isGroovy) match {
+        case (true, false) => JavaOnly
+        case (false, true) => GroovyOnly
+        case (true, true) => Mixed
+        case (false, false) => JavaOnly // fallback, though this shouldn't happen
+      }
+
       val config = GroovyCompilerConfiguration(
         enablePreview = groovyCompileEnablePreview(),
         targetBytecode = groovyCompileTargetBytecode(),
@@ -167,21 +200,14 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
           worker = jvmWorkerRef().internalWorker(),
           upstreamCompileOutput = updateCompileOutput,
           javaSourceFiles = javaSourceFiles,
-          compileCp = compileCp,
+          compileCp = compileCp :+ compileGeneratedGroovyStubs(),
           javaHome = javaHome().map(_.path),
           javacOptions = javacOptions(),
           compileProblemReporter = ctx.reporter(hashCode),
           reportOldProblems = zincReportCachedProblems()
         )
       }
 
-      def compileGroovyStubs(): Result[CompilationResult] = {
-        ctx.log.info("Compiling Groovy stubs for mixed compilation")
-        GroovyWorkerManager.groovyWorker().withValue(groovyCompilerClasspath()) {
-          _.compileGroovyStubs(groovySourceFiles, compileCp, classes, config)
-        }
-      }
-
       def compileGroovy(): Result[CompilationResult] = {
         ctx.log.info(
           s"Compiling ${groovySourceFiles.size} Groovy sources to $classes ..."
@@ -192,7 +218,7 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
           }
 
         // TODO figure out if there is a better way to do this
-        val analysisFile = dest / "groovy.analysis.dummy" // needed for mills CompilationResult
+        val analysisFile = dest / "groovy.analysis.dummy" // needed for Mills CompilationResult
         os.write(target = analysisFile, data = "", createFolders = true)
 
         workerGroovyResult match {
@@ -202,18 +228,19 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
         }
       }
 
-      val firstAndSecondStage = if (isMixed) {
-        // only compile Java if Stubs are successfully generated
-        compileGroovyStubs().flatMap(_ => compileJava)
-      } else {
-        Result.Success
-      }
+      strategy match {
+        case JavaOnly =>
+          compileJava
 
-      if (isMixed || isGroovy) {
-        firstAndSecondStage.flatMap(_ => compileGroovy())
-      } else {
-        compileJava
+        case GroovyOnly =>
+          compileGroovy()
+
+        case Mixed =>
+          compileGroovyStubs()
+            .flatMap(_ => compileJava)
+            .flatMap(_ => compileGroovy())
       }
+
     }
 
   private[groovylib] def internalCompileJavaFiles(

libs/groovylib/worker/src/mill/groovylib/worker/impl/GroovyWorkerImpl.scala

@@ -1,8 +1,7 @@
 package mill.groovylib.worker.impl
 
 import groovy.lang.GroovyClassLoader
-import mill.api.Result
-import mill.api.TaskCtx
+import mill.api.{PathRef, Result, TaskCtx}
 import mill.javalib.api.CompilationResult
 import mill.groovylib.worker.api.{GroovyCompilerConfiguration, GroovyWorker}
 import org.codehaus.groovy.control.{CompilationUnit, CompilerConfiguration, Phases}
@@ -19,13 +18,13 @@ class GroovyWorkerImpl extends GroovyWorker {
       classpath: Seq[Path],
       outputDir: Path,
       config: GroovyCompilerConfiguration
-  )(implicit ctx: TaskCtx): Result[CompilationResult] = {
+  )(implicit ctx: TaskCtx): Result[Unit] = {
     val compilerConfig = new CompilerConfiguration()
     compilerConfig.setTargetDirectory(outputDir.toIO)
     compilerConfig.setClasspathList(classpath.map(_.toIO.getAbsolutePath).asJava)
     compilerConfig.setJointCompilationOptions(Map(
       "stubDir" -> outputDir.toIO,
-      "keepStubs" -> false
+      "keepStubs" -> true
     ).asJava)
     compilerConfig.setDisabledGlobalASTTransformations(
       config.disabledGlobalAstTransformations.asJava
@@ -46,10 +45,9 @@ class GroovyWorkerImpl extends GroovyWorker {
 
     Try {
       stubUnit.compile(Phases.CONVERSION)
-      CompilationResult(outputDir, mill.api.PathRef(outputDir))
     }.fold(
       exception => Result.Failure(s"Groovy stub generation failed: ${exception.getMessage}"),
-      result => Result.Success(result)
+      result => Result.Success(())
     )
 
   }
@@ -88,19 +86,10 @@ class GroovyWorkerImpl extends GroovyWorker {
 
     Try {
       unit.compile(Phases.OUTPUT)
-      removeAllJavaFiles(outputDir)
       CompilationResult(outputDir, mill.api.PathRef(outputDir))
     }.fold(
       exception => Result.Failure(s"Groovy compilation failed: ${exception.getMessage}"),
       result => Result.Success(result)
     )
   }
-
-  private def removeAllJavaFiles(outputDir: os.Path): Unit = {
-    if (os.exists(outputDir)) {
-      os.walk(outputDir)
-        .filter(_.ext == "java")
-        .foreach(os.remove)
-    }
-  }
 }