Merge branch 'main' into tr-path-mapping-optional

Author: lefou

build.mill

@@ -1,4 +1,4 @@
-//| mill-version: 1.0.6-88-54d201
+//| mill-version: 1.0.6-95-b08901
 //| mill-jvm-opts: ["-XX:NonProfiledCodeHeapSize=250m", "-XX:ReservedCodeCacheSize=500m"]
 //| mill-opts: ["--jobs=0.5C"]
 

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

@@ -6,6 +6,14 @@ trait BspModuleApi extends ModuleApi {
   private[mill] def bspBuildTargetData: TaskApi[Option[(String, AnyRef)]]
   private[mill] def bspBuildTarget: BspBuildTarget
   private[mill] def bspDisplayName: String
+
+  /**
+   * Set this to false to make the Mill BSP server hide / ignore that module
+   *
+   * Beware that if a module depends via `moduleDeps` or `compileModuleDeps` on modules
+   * that have `enableBsp` set to false, it will be ignored by the Mill BSP server too
+   */
+  def enableBsp: Boolean = true
 }
 
 object BspModuleApi {

core/api/src/mill/api/Task.scala

@@ -504,7 +504,9 @@ object Task {
         ctx0,
         upickle.readwriter[Seq[PathRef]],
         isPrivate
-      ) {}
+      ) {
+    override def readWriterOpt = Some(upickle.readwriter[Seq[PathRef]])
+  }
 
   class Source(
       evaluate0: (Seq[Any], mill.api.TaskCtx) => Result[PathRef],
@@ -515,7 +517,9 @@ object Task {
         ctx0,
         upickle.readwriter[PathRef],
         isPrivate
-      ) {}
+      ) {
+    override def readWriterOpt = Some(upickle.readwriter[PathRef])
+  }
 
   private object Macros {
     def appImpl[M[_]: Type, T: Type](using

core/exec/src/mill/exec/GroupExecution.scala

@@ -123,7 +123,9 @@ trait GroupExecution {
             val (execRes, serializedPaths) =
               try {
                 val (resultData, serializedPaths) = PathRef.withSerializedPaths {
-                  PathRef.currentOverrideModulePath.withValue(labelled.ctx.millSourcePath) {
+                  PathRef.currentOverrideModulePath.withValue(
+                    labelled.ctx.enclosingModule.moduleCtx.millSourcePath
+                  ) {
                     upickle.read[Any](interpolateEnvVarsInJson(jsonData))(
                       using labelled.readWriterOpt.get.asInstanceOf[upickle.Reader[Any]]
                     )

dist/package.mill

@@ -9,6 +9,9 @@ import mill.util.Jvm
 import millbuild.*
 import mill.api.BuildCtx
 import scala.util.Using
+import scala.util.Properties
+import java.nio.file.Files
+import java.nio.file.attribute.PosixFilePermission
 
 trait DistModule extends Module {
   // All modules that we want to aggregate as part of this `dev` assembly.
@@ -19,9 +22,49 @@ trait DistModule extends Module {
 
   def executableRaw: T[PathRef]
 
+  def localRepo: T[PathRef] = Task {
+    val dest = Task.dest
+    val repos = Task.traverse(allPublishModules)(m => m.publishLocalTestRepo)().map(_.path)
+    for (repo <- repos; elem <- os.list(repo))
+      os.copy.into(elem, dest, mergeFolders = true)
+    PathRef(dest)
+  }
+
   def executable = Task {
-    Task.traverse(allPublishModules)(m => m.publishLocal(doc = false))()
-    executableRaw()
+    val rawExecutable = executableRaw()
+    if (Properties.isWin) {
+      val launcher = Task.dest / "mill.bat"
+      val launcherContent =
+        s"""@echo off
+           |set "NEW_COURSIER_REPOSITORIES=${localRepo().path.toNIO.toUri.toASCIIString}|ivy2Local|central"
+           |if defined COURSIER_REPOSITORIES (
+           |  set "NEW_COURSIER_REPOSITORIES=%NEW_COURSIER_REPOSITORIES%|%COURSIER_REPOSITORIES%"
+           |) else (
+           |  set "NEW_COURSIER_REPOSITORIES=%NEW_COURSIER_REPOSITORIES%|ivy2Local|central"
+           |)
+           |set "COURSIER_REPOSITORIES=%NEW_COURSIER_REPOSITORIES%"
+           |set NEW_COURSIER_REPOSITORIES=
+           |"${rawExecutable.path.toString.replace("\"", "\\\"")}" %*
+           |if errorlevel 1 exit /b %errorlevel%
+           |""".stripMargin
+      os.write(launcher, launcherContent)
+      PathRef(launcher)
+    } else {
+      val launcher = Task.dest / "mill"
+      val launcherContent =
+        s"""#!/usr/bin/env bash
+           |set -e
+           |export COURSIER_REPOSITORIES="${localRepo().path.toNIO.toUri.toASCIIString}|$${COURSIER_REPOSITORIES:-ivy2Local|central}"
+           |exec '${rawExecutable.path.toString.replace("'", "\\'")}' "$$@"
+           |""".stripMargin
+      os.write(launcher, launcherContent)
+      val perms = Files.getPosixFilePermissions(launcher.toNIO)
+      perms.add(PosixFilePermission.OWNER_EXECUTE)
+      perms.add(PosixFilePermission.GROUP_EXECUTE)
+      perms.add(PosixFilePermission.OTHERS_EXECUTE)
+      Files.setPosixFilePermissions(launcher.toNIO, perms)
+      PathRef(launcher)
+    }
   }
 
   def localBinName: String
@@ -32,38 +75,61 @@ trait DistModule extends Module {
    * Build and install Mill locally.
    *
    * @param binFile The location where the Mill binary should be installed
-   * @param ivyRepo The local Ivy repository where Mill modules should be published to
    */
-  def installLocal(binFile: String = localBinName, ivyRepo: String = null) =
-    Task.Command {
-      PathRef(installLocalTask(Task.Anon(binFile), ivyRepo)())
+  def installLocal(binFile: String = localBinName) = {
+    val binFile0 = os.Path(binFile, BuildCtx.workspaceRoot)
+    Task.Command[Unit] {
+      installIvyLocalTask(Task.Anon(binFile0))()
     }
+  }
 
   val batExt = if (scala.util.Properties.isWin) ".bat" else ""
 
-  def installLocalCachePath(suffixTask: Task[String]) = Task.Anon {
-    (os.home / ".cache/mill/download" / (build.millVersion() + suffixTask() + batExt)).toString()
-  }
+  def installLocalCache() = {
 
-  def installLocalCache() = Task.Command {
-    val path = installLocalTask(installLocalCachePath(build.dist.cacheBinarySuffix))()
-    val path2 = installLocalTask(installLocalCachePath(build.dist.native.cacheBinarySuffix))()
+    def launcherPathTask(suffix: Task[String]) =
+      Task.Anon {
+        os.home / ".cache/mill/download" / (build.millVersion() + suffix() + batExt)
+      }
 
-    Task.log.streams.out.println(path.toString())
-    PathRef(path)
-  }
+    val jarLauncherPathTask = launcherPathTask(build.dist.cacheBinarySuffix)
+    val nativeLauncherPathTask = launcherPathTask(build.dist.native.cacheBinarySuffix)
 
-  def installLocalTask(binFile: Task[String], ivyRepo: String = null): Task[os.Path] = Task.Anon {
-    val targetFile = os.Path(binFile(), BuildCtx.workspaceRoot)
-    if (os.exists(targetFile))
-      Task.log.info(s"Overwriting existing local Mill binary at ${targetFile}")
-    os.copy.over(executable().path, targetFile, createFolders = true)
-    Task.log.info(
-      s"Published ${build.dist.allPublishModules.size} modules and installed ${targetFile}"
-    )
-    targetFile
+    Task.Command {
+      val Seq(jarLauncherPath, _*) =
+        installIvyLocalTask(jarLauncherPathTask, nativeLauncherPathTask)()
+      Task.log.streams.out.println(jarLauncherPath.path.toString())
+      jarLauncherPath
+    }
   }
 
+  def installLocalTask(binFile: Task[String]): Task[os.Path] =
+    Task.Anon {
+      val targetFile = os.Path(binFile(), BuildCtx.workspaceRoot)
+      if (os.exists(targetFile))
+        Task.log.info(s"Overwriting existing local Mill binary at ${targetFile}")
+      os.copy.over(executable().path, targetFile, createFolders = true)
+      Task.log.info(
+        s"Published ${build.dist.allPublishModules.size} modules under Mill sources local repo ${localRepo().path} and installed ${targetFile}"
+      )
+      targetFile
+    }
+
+  def installIvyLocalTask(targetFiles: Task[os.Path]*) =
+    Task.Anon[Seq[PathRef]] {
+      Task.traverse(allPublishModules)(m => m.publishLocal(doc = false))()
+      val targetFiles0 = Task.sequence(targetFiles)()
+      for (targetFile <- targetFiles0) {
+        if (os.exists(targetFile))
+          Task.log.info(s"Overwriting existing local Mill binary at $targetFile")
+        os.copy.over(executableRaw().path, targetFile, createFolders = true)
+      }
+      Task.log.info(
+        s"Published ${build.dist.allPublishModules.size} modules under ~/.ivy2/local and installed ${targetFiles0.mkString(", ")}"
+      )
+      targetFiles0.map(PathRef(_))
+    }
+
   def artifactName: T[String]
   def artifact = Task { Artifact(Settings.pomOrg, artifactName(), build.millVersion()) }
   def pomSettings = Task { MillPublishJavaModule.commonPomSettings(artifactName()) }

example/cli/header/4-jvm-index-version/build.mill

@@ -0,0 +1,31 @@
+//| mill-jvm-index-version: 0.0.4-88-f9ba3d
+//| mill-jvm-version: temurin:11
+//
+// Mill uses the https://github.com/coursier/jvm-index[Coursier JVM Index] to resolve JVM
+// versions to their download location, as well as partially-qualified versions such as
+// `temurin:11` to the specific point version such as `temurin:11.0.28`. The version of
+// the JVM index is set by the version of Mill you are using, but you can override it
+// to use a newer JVM index (e.g. if you want to use a newly-released JVM not yet included
+// in Mill's jvm index version) or an older JVM index.
+//
+// The list of JVM index versions can be seen here:
+//
+// - https://repo1.maven.org/maven2/io/get-coursier/jvm/indices/[JVM Indices on Maven Central]
+//
+package build
+
+import mill._
+
+def printJavaVersion() = Task.Command {
+  println("Java version: " + System.getProperty("java.version"))
+}
+
+// This example uses an older `mill-jvm-index-version` to ensure the resolved version
+// of `temurin:11` gets appropriately downgraded from `11.0.28` (the most recent `11.x` version)
+// to `11.0.26` (the version of `11.x` available when the JVM index `0.0.4-88-f9ba3d` was released)
+/** Usage
+
+> ./mill printJavaVersion
+Java version: 11.0.26
+
+*/

example/javalib/script/10-resources/Foo.java

@@ -0,0 +1,10 @@
+//| resources: ["./resources"]
+package foo;
+
+public class Foo {
+  public static void main(String[] args) throws Exception {
+    try (var inputStream = Foo.class.getClassLoader().getResourceAsStream("file.txt")) {
+      System.out.println(new String(inputStream.readAllBytes()));
+    }
+  }
+}

example/javalib/script/10-resources/build.mill

@@ -0,0 +1,23 @@
+//// SNIPPET:ALL
+
+/** See Also: Foo.java */
+
+/** Usage
+> ./mill Foo.java
+Hello World Resource File
+*/
+
+//// SNIPPET:END
+//// SNIPPET:ALL2
+
+/** Usage
+
+> ./mill show Foo.java:assembly
+".../out/Foo.java/assembly.dest/out.jar"
+
+> out/Foo.java/assembly.dest/out.jar
+Hello World Resource File
+
+*/
+
+//// SNIPPET:END

example/javalib/script/10-resources/resources/file.txt

@@ -0,0 +1 @@
+Hello World Resource File

example/kotlinlib/module/7-resources/foo/src/Foo.kt

@@ -1,11 +1,7 @@
 package foo
 
 object Foo {
-    // Read `file.txt` from classpath
-    fun classpathResourceText(): String {
-        // Get the resource as an InputStream
-        return Foo::class.java.classLoader.getResourceAsStream("file.txt").use {
-            it.readAllBytes().toString(Charsets.UTF_8)
-        }
+    fun classpathResourceText(): String = Foo::class.java.classLoader.getResourceAsStream("file.txt").use {
+        it.readAllBytes().toString(Charsets.UTF_8)
     }
 }