fix bash script tests

Author: bishabosha

bin/scala

@@ -2,4 +2,4 @@
 
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" >& /dev/null && pwd)/.."
 
-"$ROOT/bin/common" "$ROOT/dist/target/pack/bin/scala" "$@"
+"$ROOT/bin/common" "$ROOT/dist/target/pack/bin/scala" "$@" "--offline" "--server=false"

compiler/test-resources/scripting/classpathReport.sc

@@ -1,8 +1,8 @@
-#!bin/scala -classpath 'dist/target/pack/lib/*'
+#!/usr/bin/env bin/scala
 
 import java.nio.file.Paths
 
-def main(args: Array[String]): Unit =
+// def main(args: Array[String]): Unit = // MIGRATION: Scala CLI expects `*.sc` files to be straight-line code
   val cwd = Paths.get(".").toAbsolutePath.normalize.toString.norm
   printf("cwd: %s\n", cwd)
   printf("classpath: %s\n", sys.props("java.class.path").norm)

compiler/test-resources/scripting/envtestNu.sc

@@ -0,0 +1,2 @@
+// MIGRATION: Scala CLI expects `*.sc` files to be straight-line code
+  println("Hello " + util.Properties.propOrNull("key"))

compiler/test-resources/scripting/scriptPathNu.sc

@@ -0,0 +1,13 @@
+#!/usr/bin/env bin/scala
+
+// THIS FILE IS RAN WITH SCALA CLI, which wraps scripts exposing scriptPath and args variables
+
+args.zipWithIndex.foreach { case (arg,i) => printf("arg %d: [%s]\n",i,arg) }
+
+if !scriptPath.endsWith("scriptPathNu.sc") then
+  printf( s"incorrect script.path defined as [$scriptPath]")
+else
+  printf("scriptPath: %s\n", scriptPath) // report the value
+
+extension(s: String)
+  def norm: String = s.replace('\\', '/')

compiler/test-resources/scripting/showArgs.sc

@@ -1,4 +1,4 @@
-#!/usr/bin/env scala
+#!/usr/bin/env bin/scala
 
 // precise output format expected by BashScriptsTests.scala
 def main(args: Array[String]): Unit =

compiler/test-resources/scripting/showArgsNu.sc

@@ -0,0 +1,6 @@
+#!/usr/bin/env bin/scala
+
+// precise output format expected by BashScriptsTests.scala
+// MIGRATION: Scala CLI expects `*.sc` files to be straight-line code
+for (a,i) <- args.zipWithIndex do
+  printf(s"arg %2d:[%s]\n",i,a)

compiler/test-resources/scripting/sqlDateError.sc

@@ -1,4 +1,4 @@
-#!bin/scala
+#!/usr/bin/env bin/scala
 
 def main(args: Array[String]): Unit = {
   println(new java.sql.Date(100L))

compiler/test-resources/scripting/sqlDateErrorNu.sc

@@ -0,0 +1,6 @@
+#!/usr/bin/env bin/scala
+
+// def main(args: Array[String]): Unit = { MIGRATION: Scala CLI expects `*.sc` files to be straight-line code
+  println(new java.sql.Date(100L))
+  System.err.println("SCALA_OPTS="+Option(System.getenv("SCALA_OPTS")).getOrElse(""))
+// }

compiler/test-resources/scripting/unglobClasspath.sc

@@ -1,8 +1,6 @@
-#!bin/scala -classpath 'dist/target/pack/lib/*'
+// won't compile unless classpath is set correctly
+import dotty.tools.tasty.TastyFormat
 
-// won't compile unless the hashbang line sets classpath
-import org.jline.terminal.Terminal
-
-def main(args: Array[String]) =
+// def main(args: Array[String]) = // MIGRATION: Scala CLI expects `*.sc` files to be straight-line code
   val cp = sys.props("java.class.path")
   printf("unglobbed classpath: %s\n", cp)

compiler/test/dotty/tools/scripting/BashExitCodeTests.scala

@@ -29,7 +29,7 @@ class BashExitCodeTests:
       }, expectedExitCode, exitCode)
 
   // Helpers for running scala, scalac, and scalac without the the output directory ("raw")
-  def scala(args: String*)     = verifyExit(scalaPath, args*)
+  def scala(args: String*)     = verifyExit(scalaPath, ("--offline" +: "--server=false" +: args)*)
   def scalacRaw(args: String*) = verifyExit(scalacPath, args*)
   def scalac(args: String*)    = scalacRaw(("-d" +: tmpDir +: args)*)
 
@@ -38,12 +38,16 @@ class BashExitCodeTests:
     Files.write(Files.createTempFile(tmpDir.toPath, getClass.getSimpleName, suffix), body.getBytes(UTF_8)).absPath
 
   @Test def neg = scalac(f("@main def Test = prin"))(1)
-  @Test def run = scalac(f("@main def Test = ???"))(0) & scala("-classpath", tmpDir, "Test")(1)
-  @Test def pos = scalac(f("@main def Test = ()"))(0) & scala("-classpath", tmpDir, "Test")(0)
+  @Test def run = scalac(f("@main def Test = ???"))(0) & scala("-classpath", tmpDir, "-M", "Test")(1)
+  @Test def pos = scalac(f("@main def Test = ()"))(0) & scala("-classpath", tmpDir, "-M", "Test")(0)
 
-  @Test def runNeg = scala(f("@main def Test = prin", ".sc"))(1)
-  @Test def runRun = scala(f("@main def Test = ???", ".sc"))(1)
-  @Test def runPos = scala(f("@main def Test = ()", ".sc"))(0)
+  @Test def runNeg_script = scala(f("prin", ".sc"))(1)
+  @Test def runRun_script = scala(f("???", ".sc"))(1)
+  @Test def runPos_script = scala(f("()", ".sc"))(0)
+
+  @Test def runNeg = scala(f("@main def Test = prin", ".scala"))(1)
+  @Test def runRun = scala(f("@main def Test = ???", ".scala"))(1)
+  @Test def runPos = scala(f("@main def Test = ()", ".scala"))(0)
 
   @Test def scNeg = scalac("-script", f("@main def Test = prin", ".sc"))(1)
   @Test def scRun = scalac("-script", f("@main def Test = ???", ".sc"))(1)

compiler/test/dotty/tools/scripting/BashScriptsTests.scala

@@ -5,7 +5,7 @@ package scripting
 import scala.language.unsafeNulls
 
 import java.nio.file.Paths
-import org.junit.{Test, AfterClass}
+import org.junit.{Test, Ignore, AfterClass}
 import org.junit.Assert.assertEquals
 import org.junit.Assume.assumeFalse
 import org.junit.experimental.categories.Category
@@ -50,7 +50,9 @@ object BashScriptsTests:
   val testScriptArgs = Seq(
     "a", "b", "c", "-repl", "-run", "-script", "-debug"
   )
-  val showArgsScript = testFiles.find(_.getName == "showArgs.sc").get.absPath
+  val Seq(showArgsScript, showArgsScalaCli) = Seq("showArgs.sc", "showArgsNu.sc").map { name =>
+    testFiles.find(_.getName == name).get.absPath
+  }
 
   def testFile(name: String): String =
     val file = testFiles.find(_.getName == name) match {
@@ -64,13 +66,13 @@ object BashScriptsTests:
     }
     file
 
-  val Seq(envtestSc, envtestScala) = Seq("envtest.sc", "envtest.scala").map { testFile(_) }
+  val Seq(envtestNuSc, envtestScala) = Seq("envtestNu.sc", "envtest.scala").map { testFile(_) }
 
   // create command line with given options, execute specified script, return stdout
   def callScript(tag: String, script: String, keyPre: String): String =
     val keyArg = s"$keyPre=$tag"
     printf("pass tag [%s] via [%s] to script [%s]\n", tag, keyArg, script)
-    val cmd: String = Seq("SCALA_OPTS= ", scalaPath, keyArg, script).mkString(" ")
+    val cmd: String = Seq("SCALA_OPTS= ", scalaPath, "run", keyArg, "--offline", "--server=false", script).mkString(" ")
     printf("cmd: [%s]\n", cmd)
     val (validTest, exitCode, stdout, stderr) = bashCommand(cmd)
     stderr.filter { !_.contains("Inappropriate ioctl") }.foreach { System.err.printf("stderr [%s]\n", _) }
@@ -84,13 +86,15 @@ class BashScriptsTests:
   ////////////////////////// begin tests //////////////////////
 
   /* verify that `dist/bin/scala` correctly passes args to the jvm via -J-D for script envtest.sc */
+  @Ignore // SCALA CLI does not support `-J` to pass java properties, only things like -Xmx5g
   @Test def verifyScJProperty =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
     val tag = "World1"
-    val stdout = callScript(tag, envtestSc, s"-J-Dkey")
+    val stdout = callScript(tag, envtestNuSc, s"-J-Dkey")
     assertEquals( s"Hello $tag", stdout)
 
   /* verify that `dist/bin/scala` correctly passes args to the jvm via -J-D for script envtest.scala */
+  @Ignore // SCALA CLI does not support `-J` to pass java properties, only things like -Xmx5g
   @Test def verifyScalaJProperty =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
     val tag = "World2"
@@ -101,7 +105,7 @@ class BashScriptsTests:
   @Test def verifyScDProperty =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
     val tag = "World3"
-    val stdout = callScript(tag, envtestSc, s"-Dkey")
+    val stdout = callScript(tag, envtestNuSc, s"-Dkey")
     assertEquals(s"Hello $tag", stdout)
 
   /* verify that `dist/bin/scala` can set system properties via -D for envtest.scala */
@@ -114,7 +118,9 @@ class BashScriptsTests:
   /* verify that `dist/bin/scala` can set system properties via -D when executing compiled script via -jar envtest.jar */
   @Test def saveAndRunWithDProperty =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
-    val commandline = Seq("SCALA_OPTS= ", scalaPath.relpath, "-save", envtestScala.relpath).mkString(" ")
+    val libOut = envtestScala.relpath.stripSuffix(".scala") + ".jar"
+    val commandline = Seq(
+      "SCALA_OPTS= ", scalaPath.relpath, "--power", "package", envtestScala.relpath, "-o", libOut, "--library", "--offline", "--server=false").mkString(" ")
     val (_, _, _, _) = bashCommand(commandline) // compile jar, discard output
     val testJar = testFile("envtest.jar") // jar is created by the previous bashCommand()
     if (testJar.isFile){
@@ -124,7 +130,8 @@ class BashScriptsTests:
     }
 
     val tag = "World5"
-    val commandline2 = Seq("SCALA_OPTS= ", scalaPath.relpath, s"-Dkey=$tag", testJar.relpath)
+    val commandline2 = Seq(
+      "SCALA_OPTS= ", scalaPath.relpath, "run", s"-Dkey=$tag", "-classpath", testJar.relpath, "--offline", "--server=false")
     printf("cmd[%s]\n", commandline2.mkString(" "))
     val (validTest, exitCode, stdout, stderr) = bashCommand(commandline2.mkString(" "))
     assertEquals(s"Hello $tag", stdout.mkString("/n"))
@@ -148,7 +155,11 @@ class BashScriptsTests:
   /* verify `dist/bin/scala` non-interference with command line args following script name */
   @Test def verifyScalaArgs =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
-    val commandline = (Seq("SCALA_OPTS= ", scalaPath, showArgsScript) ++ testScriptArgs).mkString(" ")
+    val commandline = (
+      Seq("SCALA_OPTS= ", scalaPath, showArgsScalaCli)
+      ++ Seq("--offline", "--server=false")
+      ++ ("--" +: testScriptArgs)
+    ).mkString(" ")
     val (validTest, exitCode, stdout, stderr) = bashCommand(commandline)
     if verifyValid(validTest) then
       var fail = false
@@ -162,13 +173,13 @@ class BashScriptsTests:
         assert(stdout == expectedOutput)
 
   /*
-   * verify that scriptPath.sc sees a valid script.path property,
-   * and that it's value is the path to "scriptPath.sc".
+   * verify that scriptPathNu.sc sees a valid script.path property,
+   * and that it's value is the path to "scriptPathNu.sc".
    */
   @Category(Array(classOf[BootstrappedOnlyTests]))
   @Test def verifyScriptPathProperty =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
-    val scriptFile = testFiles.find(_.getName == "scriptPath.sc").get
+    val scriptFile = testFiles.find(_.getName == "scriptPathNu.sc").get
     val expected = s"${scriptFile.getName}"
     printf("===> verify valid system property script.path is reported by script [%s]\n", scriptFile.getName)
     printf("calling scriptFile: %s\n", scriptFile)
@@ -177,8 +188,8 @@ class BashScriptsTests:
       stdout.foreach { printf("stdout: [%s]\n", _) }
       stderr.foreach { printf("stderr: [%s]\n", _) }
       val valid = stdout.exists { _.endsWith(expected) }
-      if valid then printf("# valid script.path reported by [%s]\n", scriptFile.getName)
-      assert(valid, s"script ${scriptFile.absPath} did not report valid script.path value")
+      if valid then printf("# valid scriptPath reported by [%s]\n", scriptFile.getName)
+      assert(valid, s"script ${scriptFile.absPath} did not report valid scriptPath value")
 
   /*
    * verify SCALA_OPTS can specify an @argsfile when launching a scala script in `dist/bin/scala`.
@@ -208,7 +219,7 @@ class BashScriptsTests:
    */
   @Test def sqlDateTest =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
-    val scriptBase = "sqlDateError"
+    val scriptBase = "sqlDateErrorNu"
     val scriptFile = testFiles.find(_.getName == s"$scriptBase.sc").get
     val testJar = testFile(s"$scriptBase.jar") // jar should not be created when scriptFile runs
     val tj = Paths.get(testJar).toFile
@@ -236,7 +247,6 @@ class BashScriptsTests:
     printf("===> verify -e <expression> is properly handled by `dist/bin/scala`\n")
     val expected = "9"
     val expression = s"println(3*3)"
-    val cmd = s"bin/scala -e $expression"
     val (validTest, exitCode, stdout, stderr) = bashCommand(s"""bin/scala -e '$expression'""")
     val result = stdout.filter(_.nonEmpty).mkString("")
     printf("stdout: %s\n", result)

compiler/test/dotty/tools/scripting/ClasspathTests.scala

@@ -51,7 +51,7 @@ class ClasspathTests:
       // convert scriptCp to a list of files
       val hashbangJars: List[File] = scriptCp.split(psep).map { _.toFile }.toList
       val hashbangClasspathJars = hashbangJars.map { _.name }.sorted.distinct // get jar basenames, remove duplicates
-      val packlibDir = s"$scriptCwd/$packLibDir" // classpathReport.sc specifies a wildcard classpath in this directory
+      val packlibDir: String = ??? /* ??? was s"$scriptCwd/$packLibDir" */ // classpathReport.sc specifies a wildcard classpath in this directory
       val packlibJars: List[File] = listJars(packlibDir) // classpath entries expected to have been reported by the script
 
       printf("%d jar files in dist/target/pack/lib\n", packlibJars.size)
@@ -84,11 +84,23 @@ class ClasspathTests:
       case Some(file) => file
 
     val relpath = testScript.toPath.relpath.norm
+    val scalaCommand = scalaPath.relpath.norm
     printf("===> unglobClasspathVerifyTest for script [%s]\n", relpath)
     printf("bash is [%s]\n", bashExe)
 
     if packBinScalaExists then
-      val bashCmdline = s"set +x ; SCALA_OPTS= $relpath"
+      val sv = packScalaVersion
+      val tastyDirGlob = s"$packMavenDir/org/scala-lang/tasty-core_3/$sv/*"
+      // ^^^^^^^^^^^^^
+      // the classpath is a glob pattern that should be unglobbed by scala command,
+      // otherwise the script could not compile because it references a class
+      // from tasty-core
+
+      val bashCmdline = Seq(
+        "set +x ;",
+        "SCALA_OPTS=",
+        scalaCommand, "run", "--classpath", s"'$tastyDirGlob'", "--offline", "--server=false", relpath
+      ).mkString(" ")
       val cmd = Array(bashExe, "-c", bashCmdline)
 
       cmd.foreach { printf("[%s]\n", _) }

compiler/test/dotty/tools/scripting/ExpressionTest.scala

@@ -44,7 +44,7 @@ class ExpressionTest:
     assert(success)
 
   def getResult(expression: String): String =
-    val (_, _, stdout, stderr) = bashCommand(s"$scalaPath -e '$expression'")
+    val (_, _, stdout, stderr) = bashCommand(s"$scalaPath -e '$expression' --offline --server=false")
     printf("stdout: %s\n", stdout.mkString("|"))
     printf("stderr: %s\n", stderr.mkString("\n", "\n", ""))
     stdout.filter(_.nonEmpty).mkString("")

compiler/test/dotty/tools/scripting/ScriptTestEnv.scala

@@ -125,9 +125,22 @@ object ScriptTestEnv {
 
 
   def packBinDir = "dist/target/pack/bin"
-  def packLibDir = "dist/target/pack/lib"
+  // def packLibDir = "dist/target/pack/lib" // replaced by packMavenDir
+  def packMavenDir = "dist/target/pack/maven2"
+  def packVersionFile = "dist/target/pack/VERSION"
   def packBinScalaExists: Boolean = Files.exists(Paths.get(s"$packBinDir/scala"))
 
+  def packScalaVersion: String = {
+    val versionFile = Paths.get(packVersionFile)
+    if Files.exists(versionFile) then
+      val lines = Files.readAllLines(versionFile).asScala
+      lines.find { _.startsWith("version:=") } match
+        case Some(line) => line.drop(9)
+        case None => sys.error(s"no version:= found in $packVersionFile")
+    else
+      sys.error(s"no $packVersionFile found")
+  }
+
   def listJars(dir: String): List[File] =
     val packlibDir = Paths.get(dir).toFile
     if packlibDir.isDirectory then

compiler/test/dotty/tools/scripting/ScriptingTests.scala

@@ -47,7 +47,10 @@ class ScriptingTests:
    */
   @Test def scriptingMainTests =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
-    for (scriptFile, scriptArgs) <- scalaFilesWithArgs(".sc") do
+    for
+      (scriptFile, scriptArgs) <- scalaFilesWithArgs(".sc")
+      if !scriptFile.getName().endsWith("Nu.sc")
+    do
       showScriptUnderTest(scriptFile)
       val unexpectedJar = script2jar(scriptFile)
       unexpectedJar.delete
@@ -66,7 +69,10 @@ class ScriptingTests:
    */
   @Test def scriptingJarTest =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
-    for (scriptFile, scriptArgs) <- scalaFilesWithArgs(".sc") do
+    for
+      (scriptFile, scriptArgs) <- scalaFilesWithArgs(".sc")
+      if !scriptFile.getName().endsWith("Nu.sc")
+    do
       showScriptUnderTest(scriptFile)
       val expectedJar = script2jar(scriptFile)
       expectedJar.delete