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

@@ -23,7 +23,7 @@ case class Settings(
   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 =>
@@ -47,23 +47,21 @@ 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 = ":"
+  final val classpathSeparator = File.pathSeparator
 
   @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 +76,8 @@ object MainGenericRunner {
           residualArgs = settings.residualArgs :+ "-verbose"
         )
       )
-    case "-with-compiler" :: tail =>
-      process(tail, settings.withCompiler)
+    case "-save" :: tail =>
+      process(tail, settings.withSave)
     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
@@ -109,6 +107,7 @@ object MainGenericRunner {
         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.scriptArgs
         scripting.Main.main(properArgs.toArray)

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,31 @@ 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 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 +82,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")

compiler/test-resources/run/myfile$.class

@@ -28,205 +28,11 @@ fi
 
 source "$PROG_HOME/bin/common"
 
-# This script operates in one of 3 usage modes:
-#   script
-#   repl
-#   run
-# execute_mode replaces mutually exclusive booleans:
-#  execute_repl=false
-#  execute_run=false
-#  execute_script=false
-setExecuteMode () {
-  case "${execute_mode-}" in
-  "") execute_mode="$1" ; shift ;;
-  *) echo "execute_mode==[${execute_mode-}], attempted overwrite by [$1]" 1>&2
-    exit 1
-    ;;
-  esac
-}
+# exec here would prevent onExit from being called, leaving terminal in unusable state
+compilerJavaClasspathArgs
+echo $jvm_cp_args
+eval "\"$JAVACMD\"" "-classpath \"$jvm_cp_args\"" "dotty.tools.MainGenericRunner" "-classpath \"$jvm_cp_args\"" "$@"
+scala_exit_status=$?
 
 
-with_compiler=false             # to add compiler jars to repl classpath
-let class_path_count=0 || true  # count classpath args, warning if more than 1
-save_compiled=false             # to save compiled script jar in script directory
-CLASS_PATH="" || true           # scala classpath
-
-# Little hack to check if all arguments are options
-all_params="$*"
-truncated_params="${*#-}"
-# options_indicator != 0 if at least one parameter is not an option
-options_indicator=$(( ${#all_params} - ${#truncated_params} - $# ))
-
-[ -n "${SCALA_OPTS-}" ] && set -- $SCALA_OPTS "$@"
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    -repl)
-      setExecuteMode 'repl'
-      shift
-      ;;
-    -run)
-      setExecuteMode 'run'
-      shift
-      ;;
-    -cp | -classpath)
-      CLASS_PATH="$2${PSEP}"
-      let class_path_count+=1
-      shift
-      shift
-      ;;
-    -cp*|-classpath*) # partial fix for #10761
-      # hashbang can combine args, e.g. "-classpath 'lib/*'"
-      CLASS_PATH="${1#* *}${PSEP}"
-      let class_path_count+=1
-      shift
-      ;;
-    -with-compiler)
-      with_compiler=true
-      shift
-      ;;
-    @*|-color:*)
-      addScala "${1}"
-      shift
-      ;;
-    -save|-savecompiled)
-      save_compiled=true
-      addScala "$1"
-      shift
-      ;;
-    -compile-only)
-      addScala "$1"
-      shift
-      ;;
-    -version)
-      # defer to scalac, then exit
-      shift
-      eval "\"$PROG_HOME/bin/scalac\" -version"
-      scala_exit_status=$?
-      onExit
-      ;;
-    -J*)
-      addJava "${1:2}"
-      addScala "${1}"
-      shift ;;
-    -v|-verbose)
-      verbose=true
-      addScala "-verbose"
-      shift ;;
-    -run)
-      setExecuteMode 'run'
-      shift ;;
-
-    *)
-      # script if extension .scala or .sc, or if has scala hashbang line
-      # no -f test, issue meaningful error message (file not found)
-      if [[ "$1" == *.scala || "$1" == *.sc ]]; then
-        setExecuteMode 'script' # execute_script=true
-
-      # -f test needed before we examine the hashbang line
-      elif [[ (-f "$1" && `head -n 1 -- "$1" | grep '#!.*scala'`) ]]; then
-        setExecuteMode 'script' # execute_script=true
-      fi
-
-      if [ "${execute_mode-}" == 'script' ]; then
-        target_script="$1"
-        shift
-        if [ ! -f $target_script ]; then
-          # likely a typo or missing script file, quit early
-          echo "not found: $target_script" 1>&2
-          scala_exit_status=2
-          onExit
-        fi
-        # all are script args
-        while [[ $# -gt 0 ]]; do
-          addScript "${1}"
-          shift
-        done
-      else
-        # all unrecognized args appearing prior to a script name
-        addResidual "$1"
-        shift
-      fi
-      ;;
-
-  esac
-done
-
-#[ -n "${dump_args}" ] && dumpArgs ; exit 2
-if [ -z "${execute_mode-}" ]; then
-  # no script was specified, set run or repl mode
-  if [[ $options_indicator -eq 0 ]]; then
-    setExecuteMode 'repl'
-  else
-    setExecuteMode 'run'
-  fi
-fi
-
-[ -n "${script_trace-}" ] && set -x
-
-case "${execute_mode-}" in
-script)
-  if [ "$CLASS_PATH" ]; then
-    script_cp_arg="-classpath '$CLASS_PATH'"
-  fi
-  setScriptName="-Dscript.path=$target_script"
-  target_jar="${target_script%.*}.jar"
-  if [[ $save_compiled == true && "$target_jar" -nt "$target_script" ]]; then
-    eval "\"$JAVACMD\"" $setScriptName -jar "$target_jar" "${script_args[@]}"
-    scala_exit_status=$?
-  else
-    [[ $save_compiled == true ]] && rm -f $target_jar
-    PROG_NAME=$ScriptingMain
-    compilerJavaClasspathArgs # initialize jvm_cp_args with toolchain classpath
-    scripting_string="-script $target_script ${script_args[@]}"
-    # use eval instead of exec, to insure that onExit is subsequently called
-
-    # $script_cp_arg must be the first argument to $ScriptingMain
-    # $scripting_string  must be last
-    eval "\"$JAVACMD\"" \
-       ${JAVA_OPTS:-$default_java_opts} \
-       "${java_args[@]}" \
-       "-classpath \"$jvm_cp_args\"" \
-       -Dscala.usejavacp=true \
-       "$setScriptName" \
-       "$ScriptingMain"  \
-        ${script_cp_arg-} \
-       "${scala_args[@]}" \
-       "${residual_args[@]}" \
-       "${scripting_string-}"    # must be the last arguments
-    scala_exit_status=$?
-  fi
-  ;;
-
-repl)
-  if [ "$CLASS_PATH" ]; then
-    repl_cparg="-classpath \"$CLASS_PATH\""
-  fi
-  eval "\"$PROG_HOME/bin/scalac\" ${repl_cparg-} ${scalac_options[@]} -repl ${residual_args[@]}"
-  scala_exit_status=$?
-  ;;
-
-run)
-  run_cparg="$DOTTY_LIB$PSEP$SCALA_LIB"
-  if [ -z "$CLASS_PATH" ]; then
-    run_cparg+="$PSEP."
-  else
-    run_cparg+="$PSEP$CLASS_PATH"
-  fi
-  if [ "$class_path_count" -gt 1 ]; then
-    echo "warning: multiple classpaths are found, scala only use the last one."
-  fi
-  if [ $with_compiler == true ]; then
-    run_cparg+="$PSEP$DOTTY_COMP$PSEP$TASTY_CORE$PSEP$DOTTY_INTF$PSEP$SCALA_ASM$PSEP$DOTTY_STAGING$PSEP$DOTTY_TASTY_INSPECTOR"
-  fi
-  # exec here would prevent onExit from being called, leaving terminal in unusable state
-  eval "\"$JAVACMD\"" "-classpath \"$run_cparg\"" "${java_args[@]}" "${residual_args[@]}"
-  scala_exit_status=$?
-  ;;
-
-*)
-  echo "warning: command option is not correct."
-  ;;
-esac
-
 onExit