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.name 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.name property matches scriptFile.getName
  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/dotc/core/Contexts.scala

@@ -273,7 +273,7 @@ object Contexts {
     /** Sourcefile corresponding to given abstract file, memoized */
     def getSource(file: AbstractFile, codec: => Codec = Codec(settings.encoding.value)) = {
       util.Stats.record("Context.getSource")
-      base.sources.getOrElseUpdate(file, new SourceFile(file, codec))
+      base.sources.getOrElseUpdate(file, SourceFile(file, codec))
     }
 
     /** SourceFile with given path name, memoized */

compiler/src/dotty/tools/dotc/util/SourceFile.scala

@@ -22,19 +22,35 @@ object ScriptSourceFile {
   @sharable private val headerPattern = Pattern.compile("""^(::)?!#.*(\r|\n|\r\n)""", Pattern.MULTILINE)
   private val headerStarts  = List("#!", "::#!")
 
+  /** Return true if has a script header */
+  def hasScriptHeader(content: Array[Char]): Boolean = {
+    headerStarts exists (content startsWith _)
+  }
+
   def apply(file: AbstractFile, content: Array[Char]): SourceFile = {
     /** Length of the script header from the given content, if there is one.
-     *  The header begins with "#!" or "::#!" and ends with a line starting
-     *  with "!#" or "::!#".
+     *  The header begins with "#!" or "::#!" and is either a single line,
+     *  or it ends with a line starting with "!#" or "::!#", if present.
      */
     val headerLength =
       if (headerStarts exists (content startsWith _)) {
         val matcher = headerPattern matcher content.mkString
         if (matcher.find) matcher.end
-        else throw new IOException("script file does not close its header with !# or ::!#")
+        else content.indexOf('\n') // end of first line
       }
       else 0
-    new SourceFile(file, content drop headerLength) {
+
+    // overwrite hash-bang lines with all spaces
+    val hashBangLines = content.take(headerLength).mkString.split("\\r?\\n")
+    if hashBangLines.nonEmpty then
+      for i <- 0 until headerLength do
+        content(i) match {
+        case '\r' | '\n' =>
+        case _ =>
+          content(i) = ' '
+        }
+
+    new SourceFile(file, content) {
       override val underlying = new SourceFile(this.file, this.content)
     }
   }
@@ -245,6 +261,24 @@ object SourceFile {
       else
         sourcePath.toString
   }
+
+  /** Return true if file is a script:
+   *  if filename extension is not .scala and has a script header.
+   */
+  def isScript(file: AbstractFile, content: Array[Char]): Boolean =
+    if file.hasExtension(".scala") then
+      false
+    else
+      ScriptSourceFile.hasScriptHeader(content)
+
+  def apply(file: AbstractFile, codec: Codec): SourceFile =
+    // see note above re: Files.exists is remarkably slow
+    val chars = try new String(file.toByteArray, codec.charSet).toCharArray
+    catch case _: java.nio.file.NoSuchFileException => Array[Char]()
+    if isScript(file, chars) then
+      ScriptSourceFile(file, chars)
+    else
+      new SourceFile(file, chars)
 }
 
 @sharable object NoSource extends SourceFile(NoAbstractFile, Array[Char]()) {

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

@@ -1,22 +1,82 @@
 package dotty.tools.scripting
 
 import java.io.File
+import java.nio.file.Path
 
 /** Main entry point to the Scripting execution engine */
 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]) =
-    val (compilerArgs, rest) = args.splitAt(args.indexOf("-script"))
+  private def distinguishArgs(args: Array[String]): (Array[String], File, Array[String], Boolean) =
+    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)
-    (compilerArgs, file, scriptArgs)
+    var saveJar = false
+    val compilerArgs = leftArgs.filter {
+      case "-save" | "-savecompiled" =>
+        saveJar = true
+        false
+      case _ =>
+        true
+    }
+    (compilerArgs, file, scriptArgs, saveJar)
   end distinguishArgs
 
   def main(args: Array[String]): Unit =
-    val (compilerArgs, scriptFile, scriptArgs) = distinguishArgs(args)
-    try ScriptingDriver(compilerArgs, scriptFile, scriptArgs).compileAndRun()
+    val (compilerArgs, scriptFile, scriptArgs, saveJar) = distinguishArgs(args)
+    val driver = ScriptingDriver(compilerArgs, scriptFile, scriptArgs)
+    try driver.compileAndRun { (outDir:Path, classpath:String, mainClass: String) =>
+      if saveJar then
+        // write a standalone jar to the script parent directory
+        writeJarfile(outDir, scriptFile, scriptArgs, classpath, mainClass)
+    }
     catch
       case ScriptingException(msg) =>
         println(s"Error: $msg")
         sys.exit(1)
+
+      case e: java.lang.reflect.InvocationTargetException =>
+        throw e.getCause
+
+  private def writeJarfile(outDir: Path, scriptFile: File, scriptArgs:Array[String],
+      classpath:String, mainClassName: String): Unit =
+
+    val javaClasspath = sys.props("java.class.path")
+    val runtimeClasspath = s"${classpath}$pathsep$javaClasspath"
+
+    val jarTargetDir: Path = Option(scriptFile.toPath.getParent) match {
+      case None => sys.error(s"no parent directory for script file [$scriptFile]")
+      case Some(parent) => parent
+    }
+
+    def scriptBasename = scriptFile.getName.takeWhile(_!='.')
+    val jarPath = s"$jarTargetDir/$scriptBasename.jar"
+
+    val cpPaths = runtimeClasspath.split(pathsep).map {
+      // protect relative paths from being converted to absolute
+      case str if str.startsWith(".") && File(str).isDirectory => s"${str.withSlash}/"
+      case str if str.startsWith(".") => str.withSlash
+      case str => File(str).toURI.toURL.toString
+    }
+
+    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.MAIN_CLASS, mainClassName),
+      (Name.CLASS_PATH, cpString),
+    )
+    import dotty.tools.io.{Jar, Directory}
+    val jar = new Jar(jarPath)
+    val writer = jar.jarWriter(manifestAttributes:_*)
+    writer.writeAllFrom(Directory(outDir))
+  end writeJarfile
+
+  def pathsep = sys.props("path.separator")
+
+  extension(pathstr:String) {
+    def withSlash:String = pathstr.replace('\\', '/')
+  }

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

@@ -17,7 +17,7 @@ import dotty.tools.dotc.config.Settings.Setting._
 import sys.process._
 
 class ScriptingDriver(compilerArgs: Array[String], scriptFile: File, scriptArgs: Array[String]) extends Driver:
-  def compileAndRun(): Unit =
+  def compileAndRun(pack:(Path, String, String) => Unit = null): Unit =
     val outDir = Files.createTempDirectory("scala3-scripting")
     val (toCompile, rootCtx) = setup(compilerArgs :+ scriptFile.getAbsolutePath, initCtx.fresh)
     given Context = rootCtx.fresh.setSetting(rootCtx.settings.outputDir,
@@ -26,7 +26,14 @@ class ScriptingDriver(compilerArgs: Array[String], scriptFile: File, scriptArgs:
     if doCompile(newCompiler, toCompile).hasErrors then
       throw ScriptingException("Errors encountered during compilation")
 
-    try detectMainMethod(outDir, ctx.settings.classpath.value).invoke(null, scriptArgs)
+    try
+      val (mainClass, mainMethod) = detectMainClassAndMethod(outDir, ctx.settings.classpath.value, scriptFile)
+      Option(pack) match
+        case Some(func) =>
+          func(outDir, ctx.settings.classpath.value, mainClass)
+        case None =>
+      end match
+      mainMethod.invoke(null, scriptArgs)
     catch
       case e: java.lang.reflect.InvocationTargetException =>
         throw e.getCause
@@ -41,12 +48,13 @@ class ScriptingDriver(compilerArgs: Array[String], scriptFile: File, scriptArgs:
     target.delete()
   end deleteFile
 
-  private def detectMainMethod(outDir: Path, classpath: String): Method =
+  private def detectMainClassAndMethod(outDir: Path, classpath: String,
+      scriptFile: File): (String, Method) =
     val outDirURL = outDir.toUri.toURL
-    val classpathUrls = classpath.split(":").map(File(_).toURI.toURL)
+    val classpathUrls = classpath.split(pathsep).map(File(_).toURI.toURL)
     val cl = URLClassLoader(classpathUrls :+ outDirURL)
 
-    def collectMainMethods(target: File, path: String): List[Method] =
+    def collectMainMethods(target: File, path: String): List[(String, Method)] =
       val nameWithoutExtension = target.getName.takeWhile(_ != '.')
       val targetPath =
         if path.nonEmpty then s"${path}.${nameWithoutExtension}"
@@ -61,7 +69,7 @@ class ScriptingDriver(compilerArgs: Array[String], scriptFile: File, scriptArgs:
         val cls = cl.loadClass(targetPath)
         try
           val method = cls.getMethod("main", classOf[Array[String]])
-          if Modifier.isStatic(method.getModifiers) then List(method) else Nil
+          if Modifier.isStatic(method.getModifiers) then List((cls.getName, method)) else Nil
         catch
           case _: java.lang.NoSuchMethodException => Nil
       else Nil
@@ -74,13 +82,16 @@ class ScriptingDriver(compilerArgs: Array[String], scriptFile: File, scriptArgs:
 
     candidates match
       case Nil =>
-        throw ScriptingException("No main methods detected in your script")
+        throw ScriptingException(s"No main methods detected in script ${scriptFile}")
       case _ :: _ :: _ =>
         throw ScriptingException("A script must contain only one main method. " +
           s"Detected the following main methods:\n${candidates.mkString("\n")}")
       case m :: Nil => m
     end match
-  end detectMainMethod
+  end detectMainClassAndMethod
+
+  def pathsep = sys.props("path.separator")
+
 end ScriptingDriver
 
 case class ScriptingException(msg: String) extends RuntimeException(msg)

compiler/test-resources/scripting/hashBang.scala

@@ -0,0 +1,20 @@
+#!/usr/bin/env scala
+# comment
+STUFF=nada
+!#
+
+def main(args: Array[String]): Unit =
+  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) }
+    stack.filter { str => str.contains(".main(") }.map {
+      _.replaceAll(".*[(]","").
+      replaceAll("\\.main\\(.*","").
+      replaceAll(".scala.*","")
+    }.distinct.take(1).mkString("")
+  }

compiler/test-resources/scripting/mainClassOnStack.scala

@@ -0,0 +1,21 @@
+#!/usr/bin/env scala
+export STUFF=nada
+#lots of other stuff that isn't valid scala
+!#
+object Zoo {
+  def main(args: Array[String]): Unit =
+    printf("mainClassFromStack: %s\n",mainFromStack)
+    assert(mainFromStack == "Zoo",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) }
+    val shortStack = stack.filter { str => str.contains(".main(") && ! str.contains("$") }.map {
+      _.replaceAll("[.].*","").replaceAll("\\s+at\\s+","")
+    }
+    // for( s <- shortStack ){ System.err.printf("[%s]\n",s) }
+    shortStack.take(1).mkString("|")
+  }
+}

compiler/test-resources/scripting/scriptName.scala

@@ -0,0 +1,13 @@
+#!/usr/bin/env scala
+
+  def main(args: Array[String]): Unit =
+    val name = Option(sys.props("script.name")) match {
+    case None => printf("no script.name property is defined\n")
+    case Some(name) =>
+      if( name == null ){
+        printf("unexpected null script.name property")
+      } else {
+        printf("script.name: %s\n",name)
+        assert(name == "scriptName.scala")
+      }
+    }

dist/bin/scala

@@ -45,6 +45,7 @@ execute_script=false
 with_compiler=false
 class_path_count=0
 CLASS_PATH=""
+save_compiled=false
 
 # Little hack to check if all arguments are options
 all_params="$*"
@@ -72,6 +73,15 @@ while [[ $# -gt 0 ]]; do
       with_compiler=true
       shift
       ;;
+    @*|-color:*)
+      addDotcOptions "${1}"
+      shift
+      ;;
+    -save|-savecompiled)
+      save_compiled=1
+      addDotcOptions "${1}"
+      shift
+      ;;
     -d)
       DEBUG="$DEBUG_STR"
       shift
@@ -82,8 +92,10 @@ while [[ $# -gt 0 ]]; do
       shift ;;
     *)
       if [ $execute_script == false ]; then
-        if [[ "$1" == *.scala ]]; then
+        # 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")
@@ -101,7 +113,17 @@ if [ $execute_script == true ]; then
   if [ "$CLASS_PATH" ]; then
     cp_arg="-classpath \"$CLASS_PATH\""
   fi
-  eval "\"$PROG_HOME/bin/scalac\" $cp_arg ${java_options[@]} ${residual_args[@]} -script $target_script ${script_args[@]}"
+  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 && -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
   if [ "$CLASS_PATH" ]; then
     cp_arg="-classpath \"$CLASS_PATH\""