changes to dist/bin/scala script:

  1. pass @<argsFile> and -color:* options to compiler
  2. add -save|-savecompiled option
  3. recognize scripts with #!.*scala regardless of extension
  4. if -save is specified and <scriptPath>.jar file is
      newer than <scriptPath> execute it (no compile)
  5. set -Dscript.path for script execution paths (script and .jar)

changes to dotty.tools.scripting package:
  1. additional compiler args splitting and filtering
  2. renamed detectMainMethod to detectMainClassAndMethod, returns
     both main class name and reflect.Method object
  3. on -save option:
     a. if compile is successful, create same-name jar file in
        <scriptPath> parent directory
     b. "java.class.path" appended to context classpath with deduplication
     c. write "Main-Class" and "Class-Path" to jar manifest

added new tests to verify the following:
  1. one line and multi-line hash bang sections are ignored by compiler
  2. main class name in stack dump is as expected when main class is declared in script
  3. main class name in stack dump is as expected when main class is not declared in script
  4. script.path property matches scriptFile.absPath
  5. verify that with -save option jar file with expected name is generated
  6. verify that without -save option, no jar file is generated
  7. generated jar file is executable via "java -jar <scriptFile>.jar"

Author: philwalk

compiler/src/dotty/tools/scripting/Main.scala

@@ -65,7 +65,7 @@ object Main:
     import java.util.jar.Attributes.Name
     val cpString:String = cpPaths.distinct.mkString(" ")
     val manifestAttributes:Seq[(Name, String)] = Seq(
-      (Name.MANIFEST_VERSION, "1.0.0"),
+      (Name.MANIFEST_VERSION, "1.0"),
       (Name.MAIN_CLASS, mainClassName),
       (Name.CLASS_PATH, cpString),
     )

compiler/test-resources/scripting/hashBang.scala renamed to compiler/test-resources/scripting/hashBang.sc

@@ -2,19 +2,24 @@
 # comment
 STUFF=nada
 !#
-
+// everything above this point should be ignored by the compiler
 def main(args: Array[String]): Unit =
+  args.zipWithIndex.foreach { case (arg,i) => printf("arg %d: [%s]\n",i,arg) }
   System.err.printf("mainClassFromStack: %s\n",mainFromStack)
   assert(mainFromStack.contains("hashBang"),s"fromStack[$mainFromStack]")
 
   lazy val mainFromStack:String = {
     val result = new java.io.StringWriter()
     new RuntimeException("stack").printStackTrace(new java.io.PrintWriter(result))
     val stack = result.toString.split("[\r\n]+").toList
-    //for( s <- stack ){ System.err.printf("[%s]\n",s) }
+    if verbose then for( s <- stack ){ System.err.printf("[%s]\n",s) }
     stack.filter { str => str.contains(".main(") }.map {
-      _.replaceAll(".*[(]","").
-      replaceAll("\\.main\\(.*","").
-      replaceAll(".scala.*","")
+      // derive main class name from stack when main object is NOT declared in source
+      _.replaceAll("[.].*","").
+      replaceAll("\\s+at\\s+","")
     }.distinct.take(1).mkString("")
   }
+
+  lazy val verbose = Option(System.getenv("DOTC_VERBOSE")) match
+    case None => false
+    case _ => true

compiler/test-resources/scripting/mainClassOnStack.sc

@@ -0,0 +1,29 @@
+#!/usr/bin/env scala
+export STUFF=nada
+#lots of other stuff that isn't valid scala
+!#
+// everything above this point should be ignored by the compiler
+object Zoo {
+  def main(args: Array[String]): Unit =
+    args.zipWithIndex.foreach { case (arg,i) => printf("arg %d: [%s]\n",i,arg) }
+    printf("mainClassFromStack: %s\n",mainClassFromStack)
+    assert(mainClassFromStack == "Zoo",s"fromStack[$mainClassFromStack]")
+
+  lazy val mainClassFromStack:String = {
+    val result = new java.io.StringWriter()
+    new RuntimeException("stack").printStackTrace(new java.io.PrintWriter(result))
+    val stack = result.toString.split("[\r\n]+").toList
+    if verbose then for( s <- stack ){ System.err.printf("[%s]\n",s) }
+    val shortStack = stack.filter { str => str.contains(".main(") && ! str.contains("$") }.map {
+      // derive main class name from stack when main object is declared in source
+      _.replaceAll("[.].*","").
+      replaceAll("\\s+at\\s+","")
+    }
+    // for( s <- shortStack ){ System.err.printf("[%s]\n",s) }
+    shortStack.take(1).mkString("|")
+  }
+
+  lazy val verbose = Option(System.getenv("DOTC_VERBOSE")) match
+    case None => false
+    case _ => true
+}

compiler/test-resources/scripting/mainClassOnStack.scala

@@ -0,0 +1,14 @@
+import java.nio.file.Paths
+
+object ScriptParent {
+  def main(args: Array[String]): Unit = {
+    args.zipWithIndex.foreach { case (arg,i) => printf("arg %d: [%s]\n",i,arg) }
+    val scriptName = Option(sys.props("script.path")) match {
+      case  None =>
+        printf("no script.path property\n")
+      case Some(script) =>
+        val p = Paths.get(script).toAbsolutePath.toFile.getParent
+        printf("parentDir: [%s]\n",p)
+    }
+  }
+}

compiler/test-resources/scripting/scriptName.scala

@@ -0,0 +1,10 @@
+#!/usr/bin/env scala
+
+  def main(args: Array[String]): Unit =
+    args.zipWithIndex.foreach { case (arg,i) => printf("arg %d: [%s]\n",i,arg) }
+    val path = Option(sys.props("script.path")) match {
+    case None => printf("no script.path property is defined\n")
+    case Some(path) =>
+      printf("script.path: %s\n",path)
+      assert(path.endsWith("scriptPath.sc"),s"actual path [$path]")
+    }

compiler/test-resources/scripting/scriptParent.scala

@@ -9,31 +9,94 @@ import org.junit.Test
 import vulpix.TestConfiguration
 
 
-/** Runs all tests contained in `compiler/test-resources/repl/` */
+/** Runs all tests contained in `compiler/test-resources/scripting/` */
 class ScriptingTests:
   extension (str: String) def dropExtension =
     str.reverse.dropWhile(_ != '.').drop(1).reverse
 
-  @Test def scriptingTests =
-    val testFiles = scripts("/scripting")
+  def testFiles = scripts("/scripting")
 
-    val argss: Map[String, Array[String]] = (
-      for
-        argFile <- testFiles
-        if argFile.getName.endsWith(".args")
-        name = argFile.getName.dropExtension
-        scriptArgs = readLines(argFile).toArray
-      yield name -> scriptArgs).toMap
+  def script2jar(scriptFile: File) = 
+    val jarName = s"${scriptFile.getName.dropExtension}.jar"
+    File(scriptFile.getParent,jarName)
 
+  def showScriptUnderTest(scriptFile: File): Unit =
+    printf("===> test script name [%s]\n",scriptFile.getName)
+
+
+  val argss: Map[String, Array[String]] = (
+    for
+      argFile <- testFiles
+      if argFile.getName.endsWith(".args")
+      name = argFile.getName.dropExtension
+      scriptArgs = readLines(argFile).toArray
+    yield name -> scriptArgs).toMap
+
+  def scalaFilesWithArgs(extension: String) = (
     for
       scriptFile <- testFiles
-      if scriptFile.getName.endsWith(".scala")
+      if scriptFile.getName.endsWith(extension)
       name = scriptFile.getName.dropExtension
       scriptArgs = argss.getOrElse(name, Array.empty[String])
-    do
+    yield scriptFile -> scriptArgs).toList.sortBy { (file,args) => file.getName }
+
+  @Test def scriptingDriverTests =
+
+    for (scriptFile,scriptArgs) <- scalaFilesWithArgs(".scala") do
+      showScriptUnderTest(scriptFile)
+      val unexpectedJar = script2jar(scriptFile)
+      unexpectedJar.delete
+
+      sys.props("script.path") = scriptFile.absPath
       ScriptingDriver(
         compilerArgs = Array(
-          "-classpath", TestConfiguration.basicClasspath),
+          "-classpath", TestConfiguration.basicClasspath
+        ),
         scriptFile = scriptFile,
         scriptArgs = scriptArgs
-      ).compileAndRun()
+      ).compileAndRun { (path:java.nio.file.Path,classpath:String, mainClass:String) =>
+        printf("mainClass from ScriptingDriver: %s\n",mainClass)
+      }
+      assert(! unexpectedJar.exists, s"not expecting jar file: ${unexpectedJar.absPath}")
+
+  @Test def scriptingMainTests =
+    for (scriptFile,scriptArgs) <- scalaFilesWithArgs(".sc") do
+      showScriptUnderTest(scriptFile)
+      val unexpectedJar = script2jar(scriptFile)
+      unexpectedJar.delete
+
+      sys.props("script.path") = scriptFile.absPath
+      val mainArgs: Array[String] = Array(
+        "-classpath", TestConfiguration.basicClasspath.toString,
+        "-script", scriptFile.toString,
+      ) ++ scriptArgs
+
+      Main.main(mainArgs)
+      assert(! unexpectedJar.exists, s"not expecting jar file: ${unexpectedJar.absPath}")
+
+  @Test def scriptingJarTest =
+    for (scriptFile,scriptArgs) <- scalaFilesWithArgs(".sc") do
+      showScriptUnderTest(scriptFile)
+      val expectedJar = script2jar(scriptFile)
+      expectedJar.delete
+
+      sys.props("script.path") = scriptFile.absPath
+      val mainArgs: Array[String] = Array(
+        "-classpath", TestConfiguration.basicClasspath.toString,
+        "-save",
+        "-script", scriptFile.toString,
+      ) ++ scriptArgs
+
+      Main.main(mainArgs)
+
+      printf("===> test script jar name [%s]\n",expectedJar.getName)
+      assert(expectedJar.exists)
+
+      import scala.sys.process._
+      val cmd = Array("java",s"-Dscript.path=${scriptFile.getName}","-jar",expectedJar.absPath)
+        ++ scriptArgs
+      Process(cmd).lazyLines_!.foreach { println }
+
+  extension(f: File){
+    def absPath = f.getAbsolutePath.replace('\\','/')
+  }

compiler/test-resources/scripting/scriptPath.sc

@@ -115,7 +115,7 @@ if [ $execute_script == true ]; then
   fi
   target_jar="${target_script%.*}.jar"
   jar_found=false
-  setScriptName="-Dscript.name=${target_script##*/}"
+  setScriptName="-Dscript.path=$target_script"
   [[ $save_compiled == true && -f "$target_jar" ]] && jar_found=true
   if [[ $jar_found == true && "$target_jar" -nt "$target_script" ]]; then
     java $setScriptName -jar "$target_jar" "${script_args[@]}"