Intial Groovy setup

Author: lostiniceland

core/api/daemon/src/mill/api/daemon/internal/GroovyModuleApi.scala

@@ -0,0 +1,3 @@
+package mill.api.daemon.internal
+
+trait GroovyModuleApi extends JavaModuleApi

core/api/daemon/src/mill/api/daemon/internal/bsp/BspModuleApi.scala

@@ -15,6 +15,7 @@ object BspModuleApi {
     val Java = "java"
     val Scala = "scala"
     val Kotlin = "kotlin"
+    val Groovy = "groovy"
   }
 
   /** Used to define the [[BspBuildTarget.tags]] field. */

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

@@ -0,0 +1,12 @@
+package mill.groovylib.worker.api
+
+import mill.api.TaskCtx
+import mill.api.Result
+import mill.javalib.api.CompilationResult
+
+trait GroovyWorker {
+
+  def compile(sourceFiles: Seq[os.Path], classpath: Seq[os.Path], outputDir: os.Path)(implicit
+      ctx: TaskCtx
+  ): Result[CompilationResult]
+}

libs/groovylib/package.mill

@@ -0,0 +1,50 @@
+package build.libs.groovylib
+
+// imports
+import mill.*
+import mill.contrib.buildinfo.BuildInfo
+import mill.scalalib.*
+import millbuild.*
+
+object `package` extends MillStableScalaModule with BuildInfo {
+
+  def moduleDeps = Seq(build.libs.javalib, build.libs.javalib.testrunner, api)
+  def localTestExtraModules =
+    super.localTestExtraModules ++ Seq(worker)
+
+  def buildInfoPackageName = "mill.groovylib"
+  def buildInfoObjectName = "Versions"
+  def buildInfoMembers = Seq(
+    BuildInfo.Value("groovyVersion", Deps.groovyVersion, "Version of Groovy")
+  )
+
+  trait MillGroovyModule extends MillPublishScalaModule {
+    override def javacOptions = super.javacOptions() ++ {
+      val release =
+        if (scala.util.Properties.isJavaAtLeast(11)) Seq("-release", "8")
+        else Seq("-source", "1.8", "-target", "1.8")
+      release ++ Seq("-encoding", "UTF-8", "-deprecation")
+    }
+  }
+
+  object api extends MillGroovyModule {
+    def moduleDeps = Seq(build.libs.javalib.testrunner)
+
+    override def compileMvnDeps: T[Seq[Dep]] = Seq(
+      Deps.osLib
+    )
+  }
+
+  object worker extends MillGroovyModule {
+    override def compileModuleDeps = Seq(api)
+
+    def mandatoryMvnDeps = Seq.empty[Dep]
+
+    override def compileMvnDeps: T[Seq[Dep]] =
+      super.mandatoryMvnDeps() ++ Seq(
+        Deps.osLib,
+        Deps.groovyCompiler
+      )
+  }
+
+}

libs/groovylib/src/mill/groovylib/GroovyMavenModule.scala

@@ -0,0 +1,20 @@
+package mill.groovylib
+
+import mill.Task
+import mill.javalib.MavenModule
+
+/**
+ * A [[GroovyModule]] with a Maven compatible directory layout:
+ * `src/main/groovy`, `src/main/resources`, etc.
+ */
+trait GroovyMavenModule extends GroovyModule with MavenModule {
+  private def sources0 = Task.Sources("src/main/groovy")
+  override def sources = super.sources() ++ sources0()
+
+  trait GroovyMavenTests extends GroovyTests with MavenTests {
+    override def sources = Task.Sources(
+      moduleDir / "src" / testModuleName / "java",
+      moduleDir / "src" / testModuleName / "groovy"
+    )
+  }
+}

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

@@ -0,0 +1,269 @@
+package mill
+package groovylib
+
+import mill.api.{ModuleRef, Result}
+import mill.javalib.api.CompilationResult
+import mill.javalib.api.JvmWorkerApi as PublicJvmWorkerApi
+import mill.api.daemon.internal.{CompileProblemReporter, GroovyModuleApi, internal}
+import mill.javalib.{Dep, JavaModule, JvmWorkerModule, Lib}
+import mill.*
+import mainargs.Flag
+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
+ */
+trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
+
+  /**
+   * The Groovy version to be used (for API and Language level settings).
+   */
+  def groovyVersion: T[String]
+
+  /**
+   * The compiler language version. Default is derived from [[groovyVersion]].
+   */
+  def groovyLanguageVersion: T[String] = Task { groovyVersion().split("[.]").take(2).mkString(".") }
+
+  override def bomMvnDeps: T[Seq[Dep]] = super.bomMvnDeps() ++ Seq(
+    mvn"org.apache.groovy:groovy-bom:${groovyVersion()}"
+  )
+
+  /**
+   * All individual source files fed into the compiler.
+   */
+  override def allSourceFiles: T[Seq[PathRef]] = Task {
+    Lib.findSourceFiles(allSources(), Seq("groovy", "java")).map(PathRef(_))
+  }
+
+  /**
+   * 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")
+  }
+
+  /**
+   * 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()))
+  }
+
+  /**
+   * The dependencies of this module.
+   * Defaults to add the groovy-stdlib dependency matching the [[groovyVersion]].
+   */
+  override def mandatoryMvnDeps: T[Seq[Dep]] = Task {
+    super.mandatoryMvnDeps() ++ Seq(
+      mvn"org.apache.groovy:groovy:${groovyVersion()}"
+    )
+  }
+
+  private def jvmWorkerRef: ModuleRef[JvmWorkerModule] = jvmWorker
+
+  override def checkGradleModules: T[Boolean] = true
+
+  /**
+   * The Java classpath resembling the Groovy compiler.
+   * Default is derived from [[groovyCompilerMvnDeps]].
+   */
+  def groovyCompilerClasspath: T[Seq[PathRef]] = Task {
+    val deps = groovyCompilerMvnDeps() ++ Seq(
+      Dep.millProjectModule("mill-libs-groovylib-worker")
+    )
+    defaultResolver().classpath(
+      deps,
+      resolutionParamsMapOpt = None
+    )
+  }
+
+  /**
+   * The Ivy/Coursier dependencies resembling the Groovy compiler.
+   *
+   * Default is derived from [[groovyCompilerVersion]].
+   */
+  def groovyCompilerMvnDeps: T[Seq[Dep]] = Task {
+    val gv = groovyVersion()
+
+    val compilerDep = mvn"org.apache.groovy:groovy:$gv"
+
+    Seq(compilerDep)
+  }
+
+  /**
+   * Compiler Plugin dependencies.
+   */
+  def groovycPluginMvnDeps: T[Seq[Dep]] = Task { Seq.empty[Dep] }
+
+  /**
+   * The resolved plugin jars
+   */
+  def groovycPluginJars: T[Seq[PathRef]] = Task {
+    val jars = defaultResolver().classpath(
+      groovycPluginMvnDeps()
+        // Don't resolve transitive jars
+        .map(d => d.exclude("*" -> "*")),
+      resolutionParamsMapOpt = None
+    )
+    jars.toSeq
+  }
+
+  /**
+   * Compiles all the sources to JVM class files.
+   */
+  override def compile: T[CompilationResult] = Task {
+    groovyCompileTask()()
+  }
+
+  /**
+   * The actual Groovy compile task (used by [[compile]] and [[groovycHelp]]).
+   */
+  protected def groovyCompileTask(): Task[CompilationResult] =
+    Task.Anon {
+      val ctx = Task.ctx()
+      val dest = ctx.dest
+      val classes = dest / "classes"
+      os.makeDir.all(classes)
+
+      val javaSourceFiles = allJavaSourceFiles().map(_.path)
+      val groovySourceFiles = allGroovySourceFiles().map(_.path)
+
+      val isGroovy = groovySourceFiles.nonEmpty
+      val isJava = javaSourceFiles.nonEmpty
+      val isMixed = isGroovy && isJava
+
+      val compileCp = compileClasspath().map(_.path).filter(os.exists)
+      val updateCompileOutput = upstreamCompileOutput()
+
+      def compileJava: Result[CompilationResult] = {
+        ctx.log.info(
+          s"Compiling ${javaSourceFiles.size} Java sources to ${classes} ..."
+        )
+        // The compile step is lazy, but its dependencies are not!
+        internalCompileJavaFiles(
+          worker = jvmWorkerRef().internalWorker(),
+          upstreamCompileOutput = updateCompileOutput,
+          javaSourceFiles = javaSourceFiles,
+          compileCp = compileCp,
+          javaHome = javaHome().map(_.path),
+          javacOptions = javacOptions(),
+          compileProblemReporter = ctx.reporter(hashCode),
+          reportOldProblems = internalReportOldProblems()
+        )
+      }
+
+      if (isMixed || isGroovy) {
+        ctx.log.info(
+          s"Compiling ${groovySourceFiles.size} Groovy sources to ${classes} ..."
+        )
+
+        val compileCp = compileClasspath().map(_.path).filter(os.exists)
+
+        val workerResult =
+          GroovyWorkerManager.groovyWorker().withValue(groovyCompilerClasspath()) {
+            _.compile(groovySourceFiles, compileCp, classes)
+          }
+
+        val analysisFile = dest / "groovy.analysis.dummy" // FIXME
+        os.write(target = analysisFile, data = "", createFolders = true)
+
+        workerResult 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
+            }
+          case Result.Failure(reason) => Result.Failure(reason)
+        }
+      } else {
+        // it's Java only
+        compileJava
+      }
+    }
+
+  /**
+   * Additional Groovy compiler options to be used by [[compile]].
+   */
+  def groovycOptions: T[Seq[String]] = Task { Seq.empty[String] }
+
+  /**
+   * Aggregation of all the options passed to the Groovy compiler.
+   * In most cases, instead of overriding this Target you want to override `groovycOptions` instead.
+   */
+  def allGroovycOptions: T[Seq[String]] = Task {
+    groovycOptions()
+  }
+
+  private[groovylib] def internalCompileJavaFiles(
+      worker: JvmWorkerApi,
+      upstreamCompileOutput: Seq[CompilationResult],
+      javaSourceFiles: Seq[os.Path],
+      compileCp: Seq[os.Path],
+      javaHome: Option[os.Path],
+      javacOptions: Seq[String],
+      compileProblemReporter: Option[CompileProblemReporter],
+      reportOldProblems: Boolean
+  )(implicit ctx: PublicJvmWorkerApi.Ctx): Result[CompilationResult] = {
+    val jOpts = JavaCompilerOptions(javacOptions)
+    worker.compileJava(
+      ZincCompileJava(
+        upstreamCompileOutput = upstreamCompileOutput,
+        sources = javaSourceFiles,
+        compileClasspath = compileCp,
+        javacOptions = jOpts.compiler,
+        incrementalCompilation = true
+      ),
+      javaHome = javaHome,
+      javaRuntimeOptions = jOpts.runtime,
+      reporter = compileProblemReporter,
+      reportCachedProblems = reportOldProblems
+    )
+  }
+
+  private[groovylib] def internalReportOldProblems: Task[Boolean] = zincReportCachedProblems
+
+  @internal
+  override def bspBuildTarget: BspBuildTarget = super.bspBuildTarget.copy(
+    languageIds = Seq(
+      BspModuleApi.LanguageId.Java,
+      BspModuleApi.LanguageId.Groovy
+    ),
+    canCompile = true,
+    canRun = true
+  )
+
+  override def prepareOffline(all: Flag): Command[Seq[PathRef]] = Task.Command {
+    (
+      super.prepareOffline(all)() ++
+        groovyCompilerClasspath()
+    ).distinct
+  }
+
+  /**
+   * A test sub-module linked to its parent module best suited for unit-tests.
+   */
+  trait GroovyTests extends JavaTests with GroovyModule {
+
+    override def groovyLanguageVersion: T[String] = outer.groovyLanguageVersion()
+    override def groovyVersion: T[String] = Task { outer.groovyVersion() }
+    override def groovycPluginMvnDeps: T[Seq[Dep]] =
+      Task { outer.groovycPluginMvnDeps() }
+      // TODO: make Xfriend-path an explicit setting
+    override def groovycOptions: T[Seq[String]] = Task {
+      // FIXME
+      outer.groovycOptions().filterNot(_.startsWith("-Xcommon-sources")) ++
+        Seq(s"-Xfriend-paths=${outer.compile().classes.path.toString()}")
+    }
+  }
+
+}
+
+// TODO maybe an StandaloneGroovyTestsModule