Adds support for //| mill-scala-library-version: 3.7.2-RC1 frontmatter.

Author: arturaz

runner/launcher/src/mill/launcher/CoursierClient.scala

@@ -12,32 +12,44 @@ import scala.concurrent.duration.Duration
 import mill.coursierutil.TestOverridesRepo
 
 object CoursierClient {
-  def resolveMillDaemon() = {
+  /**
+   * Resolves the classpath for the mill daemon.
+   *
+   * @param scalaLibraryVersion the version of the scala library to use. If not specified, the version from the
+   *                            mill build is used.
+   */
+  def resolveMillDaemon(scalaLibraryVersion: Option[String]): Array[String] = {
     val repositories = Await.result(Resolve().finalRepositories.future(), Duration.Inf)
     val coursierCache0 = FileCache[Task]()
       .withLogger(coursier.cache.loggers.RefreshLogger.create())
 
-    val artifactsResultOrError = {
-
+    val artifactsResult = {
       val resolve = Resolve()
         .withCache(coursierCache0)
-        .withDependencies(Seq(Dependency(
-          Module(Organization("com.lihaoyi"), ModuleName("mill-runner-daemon_3"), Map()),
-          VersionConstraint(mill.client.BuildInfo.millVersion)
-        )))
+        .withDependencies(Seq(
+          Dependency(
+            Module(Organization("com.lihaoyi"), ModuleName("mill-runner-daemon_3"), attributes = Map.empty),
+            VersionConstraint(mill.client.BuildInfo.millVersion)
+          )
+        ) ++ scalaLibraryVersion.map { version =>
+          Dependency(
+            Module(Organization("org.scala-lang"), ModuleName("scala3-library_3"), attributes = Map.empty),
+            VersionConstraint(version)
+          )
+        })
         .withRepositories(Seq(TestOverridesRepo) ++ repositories)
 
       resolve.either() match {
         case Left(err) => sys.error(err.toString)
-        case Right(v) =>
+        case Right(resolution) =>
           Artifacts(coursierCache0)
-            .withResolution(v)
+            .withResolution(resolution)
             .eitherResult()
             .right.get
       }
     }
 
-    artifactsResultOrError.artifacts.map(_._2.toString).toArray
+    artifactsResult.artifacts.iterator.map { case (_, file) => file.toString }.toArray
   }
 
   def resolveJavaHome(id: String): java.io.File = {

runner/launcher/src/mill/launcher/MillProcessLauncher.java

@@ -19,6 +19,9 @@
 import mill.constants.CodeGenConstants;
 import mill.constants.DaemonFiles;
 import mill.constants.EnvVars;
+import scala.None;
+import scala.None$;
+import scala.Option$;
 
 public class MillProcessLauncher {
 
@@ -120,11 +123,11 @@ static List<String> loadMillConfig(String key) throws Exception {
                 Object conf = mill.launcher.ConfigReader.readYaml(
                     buildFile, buildFile.getFileName().toString());
                 if (!(conf instanceof Map)) return new String[] {};
-                Map<String, Object> conf2 = (Map<String, Object>) conf;
+                @SuppressWarnings("unchecked") Map<String, Object> conf2 = (Map<String, Object>) conf;
 
                 if (!conf2.containsKey(key)) return new String[] {};
                 if (conf2.get(key) instanceof List) {
-                  List<String> list = (List<String>) conf2.get(key);
+                  @SuppressWarnings("unchecked") List<String> list = (List<String>) conf2.get(key);
                   String[] arr = new String[list.size()];
                   for (int i = 0; i < arr.length; i++) {
                     arr[i] = mill.constants.Util.interpolateEnvVars(list.get(i), env);
@@ -152,7 +155,15 @@ static List<String> millOpts() throws Exception {
   }
 
   static String millJvmVersion() throws Exception {
-    List<String> res = loadMillConfig("mill-jvm-version");
+    return loadMillConfigSingleValue("mill-jvm-version");
+  }
+
+  static String millScalaLibraryVersion() throws Exception {
+    return loadMillConfigSingleValue("mill-scala-library-version");
+  }
+
+  static String loadMillConfigSingleValue(String key) throws Exception {
+    List<String> res = loadMillConfig(key);
     if (res.isEmpty()) return null;
     else return res.get(0);
   }
@@ -228,10 +239,16 @@ static List<String> millLaunchJvmCommand() throws Exception {
     // extra opts
     vmOptions.addAll(millJvmOpts());
 
+    var maybeScalaLibraryVersion = millScalaLibraryVersion();
     vmOptions.add("-XX:+HeapDumpOnOutOfMemoryError");
     vmOptions.add("-cp");
+    var classPathCacheKey = 
+      "mill:" + BuildInfo.millVersion + 
+      ",scala-library-version:" + (maybeScalaLibraryVersion == null ? "default" : maybeScalaLibraryVersion);
     String[] runnerClasspath = cachedComputedValue0(
-        "resolve-runner", BuildInfo.millVersion, () -> CoursierClient.resolveMillDaemon(), arr -> {
+        "resolve-runner", classPathCacheKey,
+         () -> CoursierClient.resolveMillDaemon(Option$.MODULE$.apply(maybeScalaLibraryVersion)),
+      arr -> {
           for (String s : arr) {
             if (!Files.exists(Paths.get(s))) return false;
           }
@@ -246,6 +263,19 @@ static String[] cachedComputedValue(String name, String key, Supplier<String[]>
     return cachedComputedValue0(name, key, block, arr -> true);
   }
 
+  /**
+   * Loads a value from the cache, or computes it if it's not in the cache, or re-computes it if it's
+   * in the cache but invalid.
+   * <p>
+   * The cache is stored in the `out/mill-{name}` file and contains only a single key.
+   *
+   * @param name name of the cached value
+   * @param key key of the value in the cache. If the cache exists but the key doesn't match, the value
+   *     will be re-computed.
+   * @param block block to compute the value
+   * @param validate function to validate the value. If the value is in cache but invalid, it will be
+   *     re-computed.
+   */
   static String[] cachedComputedValue0(
       String name, String key, Supplier<String[]> block, Function<String[], Boolean> validate) {
     try {

website/docs/modules/ROOT/pages/cli/build-header.adoc

@@ -15,6 +15,7 @@ For example, a build header may look something like:
 //| mill-opts: ["--jobs=0.5C"]
 //| mill-jvm-version: temurin:11
 //| mill-jvm-opts: ["-XX:NonProfiledCodeHeapSize=250m", "-XX:ReservedCodeCacheSize=500m"]
+//| mill-scala-library-version: 3.7.2-RC1
 //| # newlines are allowed too
 //|
 //| repositories:
@@ -125,3 +126,20 @@ _build.mill_
 
 Missing environment variables are converted to the empty string.
 
+== mill-scala-library-version
+
+Mill allows you to specify the exact scala-library version you want to use for your build
+via a `mill-scala-library-version` key in the build header:
+
+_build.mill_
+
+[source]
+----
+//| mill-scala-library-version: 3.7.2-RC1
+----
+
+This allows you to use newer versions of the scala-library than the version used by Mill
+itself, as long as the version you use is backwards compatible.
+
+If `mill-scala-library-version` is not provided, Mill uses the version of scala-library
+used by Mill itself.