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 <scriptPath>.jar file is newer than <scriptPath> execute it (no compile)
  5. set -Dscript.name for both script execution paths (script or .jar)

changes to dotty.tools.scripting package:

  1. moved mainMethod execution from ScriptingDriver to Main
  2. detectMainMethod also detects main class name
  3. on -save option:
     a. generate 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
  4. additional compiler args splitting and filtering
  5. throw sys.error if .class file files generated (e.g., if script source is blank)

added new tests to verify the following:

  1. hash bang section is 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.name property matches scriptFile.getName
  5. without -save option, no jar file is generated
  6. -save option causes jar file with expected name to be generated
  7. generated jar file is directly executable via "java -jar <scriptFile>.jar"

Author: philwalk

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

@@ -11,59 +11,52 @@ import java.lang.reflect.{ Modifier, Method }
 object Main:
   /** All arguments before -script <target_script> are compiler arguments.
       All arguments afterwards are script arguments.*/
-  def distinguishArgs(args: Array[String]): (Array[String], File, Array[String], Boolean) =
+  private def distinguishArgs(args: Array[String]): (Array[String], File, Array[String], Boolean) =
     // NOTE: if -script is required but not present, quit with error.
     val (leftArgs, rest) = args.splitAt(args.indexOf("-script"))
     if( rest.size < 2 ) then
       sys.error(s"missing: -script <scriptName>")
 
     val file = File(rest(1))
     val scriptArgs = rest.drop(2)
-    var saveCompiled = false
+    var saveJar = false
     val compilerArgs = leftArgs.filter {
       case "-save" | "-savecompiled" =>
-        saveCompiled = true
+        saveJar = true
         false
       case _ =>
         true
     }
-    (compilerArgs, file, scriptArgs, saveCompiled)
+    (compilerArgs, file, scriptArgs, saveJar)
   end distinguishArgs
 
-  val pathsep = sys.props("path.separator")
-
   def main(args: Array[String]): Unit =
-    val (compilerArgs, scriptFile, scriptArgs, saveCompiled) = distinguishArgs(args)
-    if verbose then showArgs(args, compilerArgs, scriptFile, scriptArgs)
-    try
-      ScriptingDriver(compilerArgs, scriptFile, scriptArgs).compileAndRun {
-          (outDir:Path, classpath:String) =>
+    val (compilerArgs, scriptFile, scriptArgs, saveJar) = distinguishArgs(args)
+    try ScriptingDriver(compilerArgs, scriptFile, scriptArgs).compileAndRun { (outDir:Path, classpath:String) =>
       val classFiles = outDir.toFile.listFiles.toList match {
       case Nil => sys.error(s"no files below [$outDir]")
       case list => list
       }
 
       val (mainClassName, mainMethod) = detectMainMethod(outDir, classpath, scriptFile)
 
-      if saveCompiled then
+      if saveJar then
         // write a standalone jar to the script parent directory
         writeJarfile(outDir, scriptFile, scriptArgs, classpath, mainClassName)
 
-      try
-        // invoke the compiled script main method
-        mainMethod.invoke(null, scriptArgs)
-      catch
-        case e: java.lang.reflect.InvocationTargetException =>
-          throw e.getCause
-
+      // invoke the compiled script main method
+      mainMethod.invoke(null, scriptArgs)
     }
     catch
       case e:Exception =>
         e.printStackTrace
         println(s"Error: ${e.getMessage}")
         sys.exit(1)
 
-  def writeJarfile(outDir: Path, scriptFile: File, scriptArgs:Array[String],
+      case e: java.lang.reflect.InvocationTargetException =>
+        throw e.getCause
+
+  private def writeJarfile(outDir: Path, scriptFile: File, scriptArgs:Array[String],
       classpath:String, mainClassName: String): Unit =
     import java.net.{URI, URL}
     val jarTargetDir: Path = Option(scriptFile.toPath.getParent) match {
@@ -94,15 +87,6 @@ object Main:
     writer.writeAllFrom(Directory(outDir))
   end writeJarfile
 
-  lazy val verbose = Option(System.getenv("DOTC_VERBOSE")) != None
-
-  def showArgs(args:Array[String], compilerArgs:Array[String],
-      scriptFile:File, scriptArgs:Array[String]): Unit =
-    args.foreach { printf("args[%s]\n", _) }
-    compilerArgs.foreach { printf("compilerArgs[%s]\n", _) }
-    scriptArgs.foreach { printf("scriptArgs[%s]\n", _) }
-    printf("scriptFile[%s]\n", scriptFile)
-
   private def detectMainMethod(outDir: Path, classpath: String,
       scriptFile: File): (String, Method) =
     val outDirURL = outDir.toUri.toURL
@@ -115,8 +99,6 @@ object Main:
         if path.nonEmpty then s"${path}.${nameWithoutExtension}"
         else nameWithoutExtension
 
-      if verbose then printf("targetPath [%s]\n",targetPath)
-
       if target.isDirectory then
         for
           packageMember <- target.listFiles.toList
@@ -139,7 +121,6 @@ object Main:
 
     candidates match
       case Nil =>
-        if verbose then outDir.toFile.listFiles.toList.foreach { f => System.err.printf("%s\n",f.toString) }
         throw ScriptingException(s"No main methods detected in script ${scriptFile}")
       case _ :: _ :: _ =>
         throw ScriptingException("A script must contain only one main method. " +
@@ -148,6 +129,8 @@ object Main:
     end match
   end detectMainMethod
 
+  def pathsep = sys.props("path.separator")
+
   extension(pathstr:String) {
     def withSlash:String = pathstr.replace('\\', '/')
   }

compiler/test-resources/scripting/hashBang.scala

@@ -1,5 +1,6 @@
 #!/usr/bin/env scala
-export STUFF=nada
+# comment
+STUFF=nada
 !#
 
 def main(args: Array[String]): Unit =
@@ -10,9 +11,7 @@ def main(args: Array[String]): Unit =
     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)
-    }
+    //for( s <- stack ){ System.err.printf("[%s]\n",s) }
     stack.filter { str => str.contains(".main(") }.map {
       _.replaceAll(".*[(]","").
       replaceAll("[:)].*","")

compiler/test-resources/scripting/scriptName.scala

@@ -0,0 +1,6 @@
+#!/usr/bin/env scala
+
+  def main(args: Array[String]): Unit =
+    val name = sys.props("script.name")
+    printf("script.name: %s\n",name)
+    assert(name == "scriptName.scala")

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

@@ -9,36 +9,98 @@ 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")
-    testFiles.foreach { (f:File) => System.err.printf("script[%s]\n",f.toString) }
+  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)
+
+  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
+
+  @Test def scriptingDriverTests =
 
     for
       scriptFile <- testFiles
       if scriptFile.getName.endsWith(".scala")
       name = scriptFile.getName.dropExtension
       scriptArgs = argss.getOrElse(name, Array.empty[String])
     do
+      val unexpectedJar = script2jar(scriptFile)
+      unexpectedJar.delete
+
       ScriptingDriver(
         compilerArgs = Array(
-          "-classpath", TestConfiguration.basicClasspath),
+          "-classpath", TestConfiguration.basicClasspath
+        ),
         scriptFile = scriptFile,
         scriptArgs = scriptArgs
       ).compileAndRun { (path:java.nio.file.Path,classpath:String) =>
         path.toFile.listFiles.foreach { (f:File) => printf(" [%s]\n",f.getName) }
-        printf("%s\n%s\n",path,classpath.length)
+        printf("path: %s\nclasspath.length: %s\n",path,classpath.length)
+      }
+      printf("not expecting a jar file: %s\n",unexpectedJar.getName)
+      assert(! unexpectedJar.exists )
+
+  @Test def scriptingMainTests =
+
+    for
+      scriptFile <- testFiles
+      if scriptFile.getName.endsWith(".scala")
+      name = scriptFile.getName.dropExtension
+      scriptArgs = argss.getOrElse(name, Array.empty[String])
+    do
+      val unexpectedJar = script2jar(scriptFile)
+      unexpectedJar.delete
+
+      sys.props("script.name") = scriptFile.getName
+      val mainArgs: Array[String] = Array(
+        "-classpath", TestConfiguration.basicClasspath.toString,
+        "-script", scriptFile.toString,
+      ) ++ scriptArgs
+
+      Main.main(mainArgs)
+
+      printf("not expecting a jar file: %s\n",unexpectedJar.getName)
+      assert(! unexpectedJar.exists )
+
+  @Test def scriptingJarTest =
+
+    for
+      scriptFile <- testFiles
+      if scriptFile.getName.endsWith(".scala")
+      name = scriptFile.getName.dropExtension
+      scriptArgs = argss.getOrElse(name, Array.empty[String])
+    do
+      val expectedJar = script2jar(scriptFile)
+      expectedJar.delete
+
+      sys.props("script.name") = scriptFile.getName
+      val mainArgs: Array[String] = Array(
+        "-classpath", TestConfiguration.basicClasspath.toString,
+        "-save",
+        "-script", scriptFile.toString,
+      ) ++ scriptArgs
+
+      Main.main(mainArgs)
+
+      printf("expected jar file: %s\n",expectedJar.getName)
+      assert(expectedJar.exists)
+
+      extension(f: File){
+        def slashPath = f.getAbsolutePath.replace('\\','/')
       }
-      
+      import scala.sys.process._
+      val cmd = Array("java",s"-Dscript.name=${scriptFile.getName}","-jar",expectedJar.slashPath)
+        ++ scriptArgs
+      Process(cmd).lazyLines_!.foreach { println }

dist/bin/scala

@@ -92,9 +92,10 @@ while [[ $# -gt 0 ]]; do
       shift ;;
     *)
       if [ $execute_script == false ]; then
-        # also a script if has scala hash bang
+        # is a script if extension .scala or .sc or if has scala hash bang
         if [[ "$1" == *.scala || "$1" == *.sc || -f "$1" && `head -n 1 -- "$1" | grep '#!.*scala'` ]]; then
           execute_script=true
+          [ -n "$SCALA_OPTS" ] && java_options+=($SCALA_OPTS)
           target_script="$1"
         else
           residual_args+=("$1")
@@ -112,12 +113,15 @@ if [ $execute_script == true ]; then
   if [ "$CLASS_PATH" ]; then
     cp_arg="-classpath \"$CLASS_PATH\""
   fi
-  target_jar=${target_script%.*}.jar
-  if [ $save_compiled == true -a -f "$target_jar" -a $target_jar -nt $target_script ]; then
-    java -jar $target_jar
+  target_jar="${target_script%.*}.jar"
+  jar_found=false
+  setScriptName="-Dscript.name=${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[@]}"
   else
-    [ $save_compiled == true -a -f $target_jar ] && rm -f $target_jar
-    residual_args+=("-Dscript.name=${target_script##*/}")
+    [[ $save_compiled == true && -f $target_jar ]] && rm -f $target_jar
+    residual_args+=($setScriptName)
     eval "\"$PROG_HOME/bin/scalac\" $cp_arg ${java_options[@]} ${residual_args[@]} -script $target_script ${script_args[@]}"
   fi
 elif [ $execute_repl == true ] || ([ $execute_run == false ] && [ $options_indicator == 0 ]); then