Handle save scala option, move coursier tests to isolated configuration, apply requested changes

Author: BarkingBad

.github/workflows/ci.yaml

@@ -111,7 +111,7 @@ jobs:
 
       - name: Cmd Tests
         run: |
-          ./project/scripts/sbt ";scala3-bootstrapped/compile; scala3-bootstrapped/publishLocal; scala3-bootstrapped/test;sjsSandbox/run;sjsSandbox/test;sjsJUnitTests/test;sjsCompilerTests/test ;sbt-test/scripted scala2-compat/* ;configureIDE ;stdlib-bootstrapped/test:run ;stdlib-bootstrapped-tasty-tests/test"
+          ./project/scripts/sbt ";scala3-bootstrapped/compile; scala3-bootstrapped/test;sjsSandbox/run;sjsSandbox/test;sjsJUnitTests/test;sjsCompilerTests/test ;sbt-test/scripted scala2-compat/* ;configureIDE ;stdlib-bootstrapped/test:run ;stdlib-bootstrapped-tasty-tests/test; scala3-compiler-bootstrapped/scala3CompilerCoursierTest:test"
           ./project/scripts/bootstrapCmdTests
 
       - name: MiMa

.gitignore

@@ -99,3 +99,6 @@ community-build/dotty-community-build-deps
 
 # Coursier
 cs
+
+# Coursier test product
+compiler/test-coursier/run/myfile.jar

compiler/src/dotty/tools/MainGenericRunner.scala

@@ -8,6 +8,7 @@ import java.net.URLClassLoader
 import sys.process._
 import java.io.File
 import java.lang.Thread
+import scala.annotation.internal.sharable
 
 enum ExecuteMode:
   case Guess
@@ -20,10 +21,12 @@ case class Settings(
   classPath: List[String] = List.empty,
   executeMode: ExecuteMode = ExecuteMode.Guess,
   exitCode: Int = 0,
+  javaArgs: List[String] = List.empty,
+  scalaArgs: List[String] = List.empty,
   residualArgs: List[String] = List.empty,
   scriptArgs: List[String] = List.empty,
   targetScript: String = "",
-  areWithCompiler: Boolean = false,
+  save: Boolean = false,
 ) {
   def withExecuteMode(em: ExecuteMode): Settings = this.executeMode match
     case ExecuteMode.Guess =>
@@ -33,6 +36,12 @@ case class Settings(
       this.copy(exitCode = 1)
   end withExecuteMode
 
+  def withScalaArgs(args: String*): Settings =
+    this.copy(scalaArgs = scalaArgs.appendedAll(args.toList))
+
+  def withJavaArgs(args: String*): Settings =
+    this.copy(javaArgs = javaArgs.appendedAll(args.toList))
+
   def withResidualArgs(args: String*): Settings =
     this.copy(residualArgs = residualArgs.appendedAll(args.toList))
 
@@ -47,23 +56,23 @@ case class Settings(
         this.copy(exitCode = 2)
   end withTargetScript
 
-  def withCompiler: Settings =
-    this.copy(areWithCompiler = true)
+  def withSave: Settings =
+    this.copy(save = true)
 }
 
 object MainGenericRunner {
 
-  final val classpathSeparator = ":"
+  val classpathSeparator = File.pathSeparator
+
+  @sharable val javaOption = raw"""-J(.*)""".r
 
   @tailrec
   def process(args: List[String], settings: Settings): Settings = args match
     case Nil =>
       settings
-    case "-repl" :: tail =>
-      process(tail, settings.withExecuteMode(ExecuteMode.Repl))
     case "-run" :: tail =>
       process(tail, settings.withExecuteMode(ExecuteMode.Run))
-    case ("-cp" | "-classpath" | "--classpath") :: cp :: tail =>
+    case ("-cp" | "-classpath" | "--class-path") :: cp :: tail =>
       process(tail, settings.copy(classPath = settings.classPath.appended(cp)))
     case ("-version" | "--version") :: _ =>
       settings.copy(
@@ -78,8 +87,10 @@ object MainGenericRunner {
           residualArgs = settings.residualArgs :+ "-verbose"
         )
       )
-    case "-with-compiler" :: tail =>
-      process(tail, settings.withCompiler)
+    case "-save" :: tail =>
+      process(tail, settings.withSave)
+    case (o @ javaOption(striped)) :: tail =>
+      process(tail, settings.withJavaArgs(striped).withScalaArgs(o))
     case arg :: tail =>
       val line = Try(Source.fromFile(arg).getLines.toList).toOption.flatMap(_.headOption)
       if arg.endsWith(".scala") || arg.endsWith(".sc") || (line.nonEmpty && raw"#!.*scala".r.matches(line.get)) then
@@ -93,7 +104,8 @@ object MainGenericRunner {
   def main(args: Array[String]): Unit =
     val settings = process(args.toList, Settings())
     if settings.exitCode != 0 then System.exit(settings.exitCode)
-    settings.executeMode match
+
+    def run(mode: ExecuteMode): Unit = mode match
       case ExecuteMode.Repl =>
         val properArgs =
           List("-classpath", settings.classPath.mkString(classpathSeparator)).filter(Function.const(settings.classPath.nonEmpty))
@@ -104,20 +116,23 @@ object MainGenericRunner {
           val newClasspath = settings.classPath ++ getClasspath :+ "."
           List("-classpath", newClasspath.mkString(classpathSeparator)).filter(Function.const(newClasspath.nonEmpty))
             ++ settings.residualArgs
-        s"java ${properArgs.mkString(" ")}".! // For now we collect classpath that coursier provides for convenience
+        s"java ${settings.javaArgs.mkString(" ")} ${properArgs.mkString(" ")}".! // For now we collect classpath that coursier provides for convenience
       case ExecuteMode.Script =>
         val properArgs =
           List("-classpath", settings.classPath.mkString(classpathSeparator)).filter(Function.const(settings.classPath.nonEmpty))
             ++ settings.residualArgs
+            ++ (if settings.save then List("-save") else Nil)
             ++ List("-script", settings.targetScript)
+            ++ settings.scalaArgs
             ++ settings.scriptArgs
         scripting.Main.main(properArgs.toArray)
       case ExecuteMode.Guess =>
-        val properArgs =
-          List("-classpath", settings.classPath.mkString(classpathSeparator)).filter(Function.const(settings.classPath.nonEmpty))
-            ++ settings.residualArgs
-        repl.Main.main(properArgs.toArray)
+        if args.toList.forall(_.startsWith("-")) then // all are options
+          run(ExecuteMode.Repl)
+        else
+          run(ExecuteMode.Run)
 
+    run(settings.executeMode)
 
   private def getClasspath(cl: ClassLoader): Array[String] = cl match
     case null => Array()

compiler/test/dotty/tools/coursier/CoursierScalaTests.scala renamed to compiler/test-coursier/dotty/tools/coursier/CoursierScalaTests.scala

@@ -1,21 +1,32 @@
 package dotty
 package tools
-package scripting
+package coursier
 
 import java.io.File
 import java.nio.file.{Path, Paths, Files}
 import scala.sys.process._
-
 import org.junit.Test
 import org.junit.BeforeClass
-
-import vulpix.TestConfiguration
-
-import dotty.tools.absPath
+import org.junit.Assert._
 import scala.collection.mutable.ListBuffer
 
+import java.net.URLClassLoader
+import java.net.URL
+
 class CoursierScalaTests:
 
+  private def scripts(path: String): Array[File] = {
+    val dir = new File(getClass.getResource(path).getPath)
+    assert(dir.exists && dir.isDirectory, "Couldn't load scripts dir")
+    dir.listFiles
+  }
+
+  extension (f: File) private def absPath =
+    f.getAbsolutePath.replace('\\', '/')
+
+  extension (str: String) private def dropExtension =
+    str.reverse.dropWhile(_ != '.').drop(1).reverse
+
   // classpath tests are managed by scripting.ClasspathTests.scala
   def testFiles = scripts("/scripting").filter { ! _.getName.startsWith("classpath") }
 
@@ -38,29 +49,36 @@ class CoursierScalaTests:
       )
       for (line, expect) <- output zip expectedOutput do
         printf("expected: %-17s\nactual  : %s\n", expect, line)
-      assert(output == expectedOutput)
+      assertEquals(expectedOutput, output)
     scriptArgs()
 
     def version() =
       val output = CoursierScalaTests.csCmd("-version")
-      assert(output.mkString("\n").contains(sys.env("DOTTY_BOOTSTRAPPED_VERSION")))
+      assertTrue(output.mkString("\n").contains(sys.env("DOTTY_BOOTSTRAPPED_VERSION")))
     version()
 
     def emptyArgsEqualsRepl() =
       val output = CoursierScalaTests.csCmd()
-      assert(output.mkString("\n").contains("Unable to create a system terminal")) // Scala attempted to create REPL so we can assume it is working
+      assertTrue(output.mkString("\n").contains("Unable to create a system terminal")) // Scala attempted to create REPL so we can assume it is working
     emptyArgsEqualsRepl()
 
-    def repl() =
-      val output = CoursierScalaTests.csCmd("-repl")
-      assert(output.mkString("\n").contains("Unable to create a system terminal")) // Scala attempted to create REPL so we can assume it is working
-    repl()
-
     def run() =
-      val output = CoursierScalaTests.csCmd("-run", "-classpath", scripts("/run").head.getParent, "myfile")
-      assert(output.mkString("\n") == "Hello")
+      val output = CoursierScalaTests.csCmd("-run", "-classpath", scripts("/run").head.getParentFile.getParent, "run.myfile")
+      assertEquals(output.mkString("\n"), "Hello")
     run()
 
+    def notOnlyOptionsEqualsRun() =
+      val output = CoursierScalaTests.csCmd("-classpath", scripts("/run").head.getParentFile.getParent, "run.myfile")
+      assertEquals(output.mkString("\n"), "Hello")
+    notOnlyOptionsEqualsRun()
+
+    def jar() =
+      val source = new File(getClass.getResource("/run/myfile.scala").getPath)
+      val output = CoursierScalaTests.csCmd("-save", source.absPath)
+      assertEquals(output.mkString("\n"), "Hello")
+      assertTrue(source.getParentFile.listFiles.find(_.getName == "myfile.jar").isDefined)
+    jar()
+
 object CoursierScalaTests:
 
   def execCmd(command: String, options: String*): List[String] =
@@ -69,7 +87,6 @@ object CoursierScalaTests:
     cmd.!(ProcessLogger(out += _, out += _))
     out.toList
 
-
   def csCmd(options: String*): List[String] =
     val newOptions = options match
       case Nil => options

compiler/test-resources/run/myfile.scala renamed to compiler/test-coursier/run/myfile.scala

@@ -1,2 +1,4 @@
+package run
+
 object myfile extends App:
   println("Hello")