Bump Scala 3 Next RC to 3.8.0-RC1

build.mill.scala

@@ -115,9 +115,6 @@ object `scala-cli-bsp` extends JavaModule with ScalaCliPublishModule {
   override def ivyDeps: T[Agg[Dep]] = super.ivyDeps() ++ Seq(
     Deps.bsp4j
   )
-  override def javacOptions: T[Seq[String]] = Task {
-    super.javacOptions() ++ Seq("-target", "8", "-source", "8")
-  }
 }
 object integration extends CliIntegration {
   object test extends IntegrationScalaTests {
@@ -773,14 +770,7 @@ trait Build extends ScalaCliCrossSbtModule
 
 trait SpecificationLevel extends ScalaCliCrossSbtModule
     with ScalaCliPublishModule {
-  override def crossScalaVersion: String     = crossValue
-  override def scalacOptions: T[Seq[String]] = Task {
-    val isScala213   = crossScalaVersion.startsWith("2.13.")
-    val extraOptions =
-      if (isScala213) Seq("-Xsource:3")
-      else Nil
-    super.scalacOptions() ++ extraOptions ++ Seq("-release", "8")
-  }
+  override def crossScalaVersion: String = crossValue
 }
 
 trait Cli extends CrossSbtModule with ProtoBuildModule with CliLaunchers
@@ -1038,6 +1028,10 @@ trait CliIntegration extends SbtModule with ScalaCliPublishModule with HasTests
            |  def scala3Next                   = "${Scala.scala3Next}"
            |  def scala3NextAnnounced          = "${Scala.scala3NextAnnounced}"
            |  def defaultScala                 = "${Scala.defaultUser}"
+           |  def scala38Versions              = Seq(${Scala.scala38Versions
+            .sorted
+            .map(s => s"\"$s\"")
+            .mkString(", ")})
            |  def defaultScalafmtVersion       = "${Deps.scalafmtCli.dep.versionConstraint.asString}"
            |  def maxAmmoniteScala212Version   = "${Scala.maxAmmoniteScala212Version}"
            |  def maxAmmoniteScala213Version   = "${Scala.maxAmmoniteScala213Version}"
@@ -1240,7 +1234,7 @@ trait Runner extends CrossSbtModule
     with ScalaCliPublishModule
     with ScalaCliScalafixModule {
   override def scalacOptions: T[Seq[String]] = Task {
-    super.scalacOptions() ++ Seq("-release", "8", "-deprecation")
+    super.scalacOptions() ++ Seq("-deprecation")
   }
   override def mainClass: T[Option[String]] = Some("scala.cli.runner.Runner")
   override def sources: T[Seq[PathRef]]     = Task.Sources {
@@ -1255,7 +1249,7 @@ trait TestRunner extends CrossSbtModule
     with ScalaCliPublishModule
     with ScalaCliScalafixModule {
   override def scalacOptions: T[Seq[String]] = Task {
-    super.scalacOptions() ++ Seq("-release", "8", "-deprecation")
+    super.scalacOptions() ++ Seq("-deprecation")
   }
   override def ivyDeps: T[Agg[Dep]] = super.ivyDeps() ++ Agg(
     Deps.asm,

modules/build/src/test/scala/scala/build/tests/SourceGeneratorTests.scala

@@ -4,7 +4,7 @@ import com.eed3si9n.expecty.Expecty.expect
 
 import scala.Console.println
 import scala.build.Ops.EitherThrowOps
-import scala.build.options.{BuildOptions, InternalOptions, Scope}
+import scala.build.options.{BuildOptions, InternalOptions}
 import scala.build.tests.util.BloopServer
 import scala.build.{Build, BuildThreads, Directories, LocalRepo, Position}
 

modules/config/src/main/scala/scala/cli/config/Keys.scala

@@ -1,7 +1,4 @@
 package scala.cli.config
-
-import com.github.plokhotnyuk.jsoniter_scala.core.Key as _
-
 import scala.cli.commands.SpecificationLevel
 
 object Keys {

modules/integration/src/test/scala/scala/cli/integration/BspTestDefinitions.scala

@@ -458,16 +458,17 @@ abstract class BspTestDefinitions extends ScalaCliSuite
   }
 
   test("directives in multiple files diagnostics") {
-    val inputs = TestInputs(
+    val javaVersion = Constants.allJavaVersions.filter(_ > Constants.defaultJvmVersion).min
+    val inputs      = TestInputs(
       os.rel / "Foo.scala" ->
-        s"""//> using scala 3.3.0
+        s"""//> using scala $actualScalaVersion
            |
            |object Foo extends App {
            |  println("Foo")
            |}
            |""".stripMargin,
       os.rel / "Bar.scala"  -> "",
-      os.rel / "Hello.java" -> "//> using jvm 11"
+      os.rel / "Hello.java" -> s"//> using jvm $javaVersion"
     )
 
     withBsp(inputs, Seq(".")) { (root, localClient, remoteServer) =>
@@ -522,8 +523,20 @@ abstract class BspTestDefinitions extends ScalaCliSuite
           )
         }
 
-        checkDirectivesInMultipleFilesWarnings("Foo.scala", 0, 0, 0, 21)
-        checkDirectivesInMultipleFilesWarnings("Hello.java", 0, 0, 0, 16)
+        checkDirectivesInMultipleFilesWarnings(
+          fileName = "Foo.scala",
+          expectedStartLine = 0,
+          expectedStartCharacter = 0,
+          expectedEndLine = 0,
+          expectedEndCharacter = 16 + actualScalaVersion.length
+        )
+        checkDirectivesInMultipleFilesWarnings(
+          fileName = "Hello.java",
+          expectedStartLine = 0,
+          expectedStartCharacter = 0,
+          expectedEndLine = 0,
+          expectedEndCharacter = 16
+        )
       }
     }
   }
@@ -2232,7 +2245,7 @@ abstract class BspTestDefinitions extends ScalaCliSuite
     if actualScalaVersion.coursierVersion >= "3.5.0".coursierVersion
     scalaVersion =
       if actualScalaVersion == Constants.scala3NextRc then Constants.scala3NextRcAnnounced
-      if actualScalaVersion == Constants.scala3Next then Constants.scala3NextAnnounced
+      else if actualScalaVersion == Constants.scala3Next then Constants.scala3NextAnnounced
       else actualScalaVersion
     withLauncher = (root: os.Path) =>
       (f: Seq[os.Shellable] => Unit) =>

modules/integration/src/test/scala/scala/cli/integration/CompileTestDefinitions.scala

@@ -328,58 +328,95 @@ abstract class CompileTestDefinitions
     TestInputs(os.rel / "Main.scala" -> s"object Main{java.util.Optional.of(1).isPresent}")
   val scalaJvm11Project: TestInputs =
     TestInputs(os.rel / "Main.scala" -> s"object Main{java.util.Optional.of(1).isEmpty}")
+  val scalaJvm17Project: TestInputs =
+    TestInputs(os.rel / "Main.scala" -> s"object Main{java.util.HexFormat.of().toHexDigits(255)}")
+  val scalaJvm23Project: TestInputs =
+    TestInputs(
+      os.rel / "Main.scala" -> s"object Main{System.out.println(javax.print.attribute.standard.OutputBin.LEFT)}"
+    )
   val javaJvm8Project: TestInputs =
     TestInputs(os.rel / "Main.java" -> """|public class Main{
                                           |  public static void main(String[] args) {
                                           |      java.util.Optional.of(1).isPresent();
                                           |  }
                                           |}""".stripMargin)
-
   val javaJvm11Project: TestInputs =
     TestInputs(os.rel / "Main.java" -> """|public class Main{
                                           |  public static void main(String[] args) {
                                           |      java.util.Optional.of(1).isEmpty();
                                           |  }
                                           |}""".stripMargin)
+  val javaJvm17Project: TestInputs =
+    TestInputs(os.rel / "Main.java" -> """|public class Main{
+                                          |  public static void main(String[] args) {
+                                          |      java.util.HexFormat.of().toHexDigits(255);
+                                          |  }
+                                          |}""".stripMargin)
+  val javaJvm23Project: TestInputs =
+    TestInputs(os.rel / "Main.java" -> """|public class Main{
+                                          |  public static void main(String[] args) {
+                                          |      System.out.println(javax.print.attribute.standard.OutputBin.LEFT);
+                                          |  }
+                                          |}""".stripMargin)
 
-  val inputs: Map[(String, Int), TestInputs] = Map(
-    ("scala", 8)  -> scalaJvm8Project,
-    ("scala", 11) -> scalaJvm11Project,
-    ("java", 8)   -> javaJvm8Project,
-    ("java", 11)  -> javaJvm11Project
-  )
+  def inputs: Map[(String, Int), TestInputs] =
+    if isScala38OrNewer
+    then
+      Map(
+        ("scala", 17) -> scalaJvm17Project,
+        ("scala", 23) -> scalaJvm23Project,
+        ("java", 17)  -> javaJvm17Project,
+        ("java", 23)  -> javaJvm23Project
+      )
+    else
+      Map(
+        ("scala", 8)  -> scalaJvm8Project,
+        ("scala", 11) -> scalaJvm11Project,
+        ("scala", 17) -> scalaJvm17Project,
+        ("scala", 23) -> scalaJvm23Project,
+        ("java", 8)   -> javaJvm8Project,
+        ("java", 11)  -> javaJvm11Project,
+        ("java", 17)  -> javaJvm17Project,
+        ("java", 23)  -> javaJvm23Project
+      )
 
-  for {
-    bloopJvm                      <- List(8, 11)
-    targetJvm                     <- List(8, 11)
-    ((lang, sourcesJvm), project) <- inputs
-  } test(s"JvmCompatibilityTest: bloopJvm:$bloopJvm/targetJvm:$targetJvm/lang:$lang/sourcesJvm:$sourcesJvm"
-    .tag(jvmT)) {
-    compileToADifferentJvmThanBloops(
-      bloopJvm.toString,
-      targetJvm.toString,
-      targetJvm >= sourcesJvm,
-      project
-    )
+  {
+    val legacyJvms  = List(8, 11)
+    val currentJvms = List(17, 23)
+    val jvms        = if isScala38OrNewer then currentJvms else legacyJvms ++ currentJvms
+    for {
+      bloopJvm                      <- jvms
+      targetJvm                     <- jvms
+      ((lang, sourcesJvm), project) <- inputs
+    } test(s"JvmCompatibilityTest: bloopJvm:$bloopJvm/targetJvm:$targetJvm/lang:$lang/sourcesJvm:$sourcesJvm"
+      .tag(jvmT)) {
+      compileToADifferentJvmThanBloops(
+        bloopJvm.toString,
+        targetJvm.toString,
+        targetJvm >= sourcesJvm,
+        project
+      )
+    }
   }
 
   test("Scala CLI should not infer scalac --release if --release is passed".tag(jvmT)) {
-    scalaJvm11Project.fromRoot { root =>
+    scalaJvm23Project.fromRoot { root =>
       val res = os.proc(
         TestUtil.cli,
         "compile",
         extraOptions,
         "--jvm",
-        "11",
+        "23",
         "-release",
-        "8",
+        "17",
         "."
       ).call(cwd = root, check = false, stderr = os.Pipe)
       expect(res.exitCode != 0)
       val errOutput = res.err.trim()
-      expect(errOutput.contains("isEmpty is not a member"))
+      System.err.println(errOutput)
+      expect(errOutput.contains("OutputBin is not a member"))
       expect(errOutput.contains(
-        "Warning: different target JVM (11) and scala compiler target JVM (8) were passed."
+        "Warning: different target JVM (23) and scala compiler target JVM (17) were passed."
       ))
     }
   }
@@ -426,12 +463,13 @@ abstract class CompileTestDefinitions
       )
       val res = os.proc(TestUtil.cli, "compile", extraOptions, "--jvm", targetJvm, ".")
         .call(cwd = root, check = false, stderr = os.Pipe)
-      expect((res.exitCode == 0) == shouldSucceed)
-      if (!shouldSucceed)
+      val succeeded = res.exitCode == 0
+      if succeeded != shouldSucceed then System.err.println(res.err.text())
+      expect(succeeded == shouldSucceed)
+      if !shouldSucceed then
         expect(
-          res.err.text().contains("value isEmpty is not a member") || res.err.text().contains(
-            "cannot find symbol"
-          )
+          res.err.text().contains("is not a member") ||
+          res.err.text().contains("cannot find symbol")
         )
     }
   if (actualScalaVersion.startsWith("2.12"))
@@ -743,7 +781,7 @@ abstract class CompileTestDefinitions
     val filename = "Main.scala"
     val inputs   = TestInputs(
       os.rel / filename ->
-        """|object Main extends App {
+        """|object Main {
            |  val msg: String = "1"
            |}
            |""".stripMargin
@@ -755,17 +793,16 @@ abstract class CompileTestDefinitions
         mergeErrIntoOut = true
       )
 
-      assertEquals(
-        TestUtil.fullStableOutput(result),
-        s"""|Compiling project (Scala $actualScalaVersion, JVM (${Constants
-             .defaultGraalVMJavaVersion}))
-            |Compiled project (Scala $actualScalaVersion, JVM (${Constants
-             .defaultGraalVMJavaVersion}))""".stripMargin
-      )
+      val jvmVersion     = Constants.defaultGraalVMJavaVersion
+      val expectedOutput =
+        s"""|Compiling project (Scala $actualScalaVersion, JVM ($jvmVersion))
+            |Compiled project (Scala $actualScalaVersion, JVM ($jvmVersion))""".stripMargin
+      val actualOutput = TestUtil.fullStableOutput(result)
+      assertEquals(actualOutput, expectedOutput)
 
       os.write.over(
         root / filename,
-        """|object Main extends App {
+        """|object Main {
            |    val msg: String = 1
            |}
            |""".stripMargin
@@ -777,30 +814,29 @@ abstract class CompileTestDefinitions
         mergeErrIntoOut = true
       )
 
-      val expectedError = if (actualScalaVersion.startsWith("2"))
-        """|[error] type mismatch;
-           |[error]  found   : Int(1)
-           |[error]  required: String""".stripMargin
-      else
-        """|[error] Found:    (1 : Int)
-           |[error] Required: String""".stripMargin
+      val expectedError =
+        if actualScalaVersion.startsWith("2") then
+          """|[error] type mismatch;
+             |[error]  found   : Int(1)
+             |[error]  required: String""".stripMargin
+        else
+          """|[error] Found:    (1 : Int)
+             |[error] Required: String""".stripMargin
 
-      assertEquals(
-        TestUtil.fullStableOutput(result2).trim,
-        s"""|Compiling project (Scala $actualScalaVersion, JVM (${Constants
-             .defaultGraalVMJavaVersion}))
+      val actualOutput2   = TestUtil.fullStableOutput(result2).trim
+      val expectedOutput2 =
+        s"""|Compiling project (Scala $actualScalaVersion, JVM ($jvmVersion))
             |[error] .${File.separatorChar}Main.scala:2:23
             |$expectedError
             |[error]     val msg: String = 1
             |[error]                       ^
-            |Error compiling project (Scala $actualScalaVersion, JVM (${Constants
-             .defaultGraalVMJavaVersion}))
+            |Error compiling project (Scala $actualScalaVersion, JVM ($jvmVersion))
             |Compilation failed""".stripMargin
-      )
+      assertEquals(actualOutput2, expectedOutput2)
 
       os.write.over(
         root / filename,
-        """|object Main extends App {
+        """|object Main {
            |    val msg: String = "1"
            |}
            |""".stripMargin
@@ -812,14 +848,11 @@ abstract class CompileTestDefinitions
         mergeErrIntoOut = true
       )
 
-      assertEquals(
-        TestUtil.fullStableOutput(result3),
-        s"""|Compiling project (Scala $actualScalaVersion, JVM (${Constants
-             .defaultGraalVMJavaVersion}))
-            |Compiled project (Scala $actualScalaVersion, JVM (${Constants
-             .defaultGraalVMJavaVersion}))""".stripMargin
-      )
-
+      val actualOutput3   = TestUtil.fullStableOutput(result3)
+      val expectedOutput3 =
+        s"""|Compiling project (Scala $actualScalaVersion, JVM ($jvmVersion))
+            |Compiled project (Scala $actualScalaVersion, JVM ($jvmVersion))""".stripMargin
+      assertEquals(actualOutput3, expectedOutput3)
     }
   }