+ added more robust detection of relative classpath entries

+ convert relative to absolute entries in manifest for equivalent classpath.
  manifest classpath entries would be relative to jar file location, not cwd.
+ added "-compile-only" option for compile without calling script main
+ added tests to verify "-compile-only" option
+ cleanup tests, update comments.
+ extensive manual experimentation on Windows and Ubuntu
+ jar file startup latency is 1/3 to 1/4 of compile and invoke latency.
+ manual tests of graalvm native-image compile of generated script jars

Author: philwalk

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

@@ -2,35 +2,41 @@ package dotty.tools.scripting
 
 import java.io.File
 import java.nio.file.Path
+import dotty.tools.dotc.config.Properties.isWin 
 
 /** 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.*/
-  private def distinguishArgs(args: Array[String]): (Array[String], File, Array[String], Boolean) =
+  private def distinguishArgs(args: Array[String]): (Array[String], File, Array[String], Boolean, Boolean) =
     val (leftArgs, rest) = args.splitAt(args.indexOf("-script"))
     assert(rest.size >= 2,s"internal error: rest == Array(${rest.mkString(",")})")
 
     val file = File(rest(1))
     val scriptArgs = rest.drop(2)
     var saveJar = false
+    var invokeFlag = true // by default, script main method is invoked
     val compilerArgs = leftArgs.filter {
       case "-save" | "-savecompiled" =>
         saveJar = true
         false
+      case "-compile-only" =>
+        invokeFlag = false // no call to script main method
+        false
       case _ =>
         true
     }
-    (compilerArgs, file, scriptArgs, saveJar)
+    (compilerArgs, file, scriptArgs, saveJar, invokeFlag)
   end distinguishArgs
 
   def main(args: Array[String]): Unit =
-    val (compilerArgs, scriptFile, scriptArgs, saveJar) = distinguishArgs(args)
+    val (compilerArgs, scriptFile, scriptArgs, saveJar, invokeFlag) = 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)
+      invokeFlag
     }
     catch
       case ScriptingException(msg) =>
@@ -54,12 +60,7 @@ object Main:
     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
-    }
+    val cpPaths = runtimeClasspath.split(pathsep).map(_.absPath)
 
     import java.util.jar.Attributes.Name
     val cpString:String = cpPaths.distinct.mkString(" ")
@@ -79,6 +80,29 @@ object Main:
 
   def pathsep = sys.props("path.separator")
 
-  extension(pathstr:String) {
-    def withSlash:String = pathstr.replace('\\', '/')
+
+  extension(file: File){
+    def norm: String = file.toString.norm
+  }
+
+  extension(path: String) {
+    // Normalize path separator, convert relative path to absolute
+    def norm: String =
+      path.replace('\\', '/') match {
+        case s if s.secondChar == ":" => s.drop(2)
+        case s if s.startsWith("./") => s.drop(2)
+        case s => s
+      }
+   
+    // convert to absolute path relative to cwd.
+    def absPath: String = norm match
+      case str if str.isAbsolute => norm
+      case _ => s"/${sys.props("user.dir").norm}/$norm"
+
+    def absFile: File = File(path.absPath)
+
+    // Treat norm paths with a leading '/' as absolute.
+    // Windows java.io.File#isAbsolute treats them as relative.
+    def isAbsolute = path.norm.startsWith("/") || (isWin && path.secondChar == ":")
+    def secondChar: String = path.take(2).drop(1).mkString("")
   }

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(pack:(Path, String, String) => Unit = null): Unit =
+  def compileAndRun(pack:(Path, String, String) => Boolean = 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,
@@ -28,12 +28,14 @@ class ScriptingDriver(compilerArgs: Array[String], scriptFile: File, 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)
+      val invokeMain: Boolean =
+        Option(pack) match
+          case Some(func) =>
+            func(outDir, ctx.settings.classpath.value, mainClass)
+          case None =>
+            true
+        end match
+      if invokeMain then mainMethod.invoke(null, scriptArgs)
     catch
       case e: java.lang.reflect.InvocationTargetException =>
         throw e.getCause

compiler/test-resources/scripting/touchFile.sc

@@ -0,0 +1,8 @@
+#!/usr/bin/env scala
+
+import java.io.File
+
+// create an empty file
+def main(args: Array[String]): Unit =
+  val file = File("touchedFile.out")
+  file.createNewFile();

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

@@ -14,6 +14,9 @@ class ScriptingTests:
   extension (str: String) def dropExtension =
     str.reverse.dropWhile(_ != '.').drop(1).reverse
 
+  extension(f: File) def absPath =
+    f.getAbsolutePath.replace('\\','/')
+
   def testFiles = scripts("/scripting")
 
   def script2jar(scriptFile: File) = 
@@ -23,7 +26,6 @@ class ScriptingTests:
   def showScriptUnderTest(scriptFile: File): Unit =
     printf("===> test script name [%s]\n",scriptFile.getName)
 
-
   val argss: Map[String, Array[String]] = (
     for
       argFile <- testFiles
@@ -40,8 +42,17 @@ class ScriptingTests:
       scriptArgs = argss.getOrElse(name, Array.empty[String])
     yield scriptFile -> scriptArgs).toList.sortBy { (file,args) => file.getName }
 
-  @Test def scriptingDriverTests =
+  def callExecutableJar(script: File,jar: File, scriptArgs: Array[String] = Array.empty[String]) = {
+    import scala.sys.process._
+    val cmd = Array("java",s"-Dscript.path=${script.getName}","-jar",jar.absPath)
+      ++ scriptArgs
+    Process(cmd).lazyLines_!.foreach { println }
+  }
 
+  /*
+   * Call .scala scripts without -save option, verify no jar created
+   */
+  @Test def scriptingDriverTests =
     for (scriptFile,scriptArgs) <- scalaFilesWithArgs(".scala") do
       showScriptUnderTest(scriptFile)
       val unexpectedJar = script2jar(scriptFile)
@@ -56,9 +67,13 @@ class ScriptingTests:
         scriptArgs = scriptArgs
       ).compileAndRun { (path:java.nio.file.Path,classpath:String, mainClass:String) =>
         printf("mainClass from ScriptingDriver: %s\n",mainClass)
+        true // call compiled script main method
       }
       assert(! unexpectedJar.exists, s"not expecting jar file: ${unexpectedJar.absPath}")
 
+  /*
+   * Call .sc scripts without -save option, verify no jar created
+   */
   @Test def scriptingMainTests =
     for (scriptFile,scriptArgs) <- scalaFilesWithArgs(".sc") do
       showScriptUnderTest(scriptFile)
@@ -74,6 +89,9 @@ class ScriptingTests:
       Main.main(mainArgs)
       assert(! unexpectedJar.exists, s"not expecting jar file: ${unexpectedJar.absPath}")
 
+  /*
+   * Call .sc scripts with -save option, verify jar is created.
+   */
   @Test def scriptingJarTest =
     for (scriptFile,scriptArgs) <- scalaFilesWithArgs(".sc") do
       showScriptUnderTest(scriptFile)
@@ -92,11 +110,74 @@ class ScriptingTests:
       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('\\','/')
-  }
+      callExecutableJar(scriptFile, expectedJar, scriptArgs)
+
+  /*
+   * Verify that when ScriptingDriver callback returns true, main is called.
+   * Verify that when ScriptingDriver callback returns false, main is not called.
+   */
+  @Test def scriptCompileOnlyTests =
+    val scriptFile = touchFileScript
+    showScriptUnderTest(scriptFile)
+
+    // verify main method not called when false is returned
+    printf("testing script compile, with no call to script main method.\n")
+    touchedFile.delete
+    assert(!touchedFile.exists, s"unable to delete ${touchedFile}")
+    ScriptingDriver(
+      compilerArgs = Array("-classpath", TestConfiguration.basicClasspath),
+      scriptFile = scriptFile,
+      scriptArgs = Array.empty[String]
+    ).compileAndRun { (path:java.nio.file.Path,classpath:String, mainClass:String) =>
+      printf("success: no call to main method in mainClass: %s\n",mainClass)
+      false // no call to compiled script main method
+    }
+    touchedFile.delete
+    assert( !touchedFile.exists, s"unable to delete ${touchedFile}" )
+
+    // verify main method is called when true is returned
+    printf("testing script compile, with call to script main method.\n")
+    ScriptingDriver(
+      compilerArgs = Array("-classpath", TestConfiguration.basicClasspath),
+      scriptFile = scriptFile,
+      scriptArgs = Array.empty[String]
+    ).compileAndRun { (path:java.nio.file.Path,classpath:String, mainClass:String) =>
+      printf("call main method in mainClass: %s\n",mainClass)
+      true // call compiled script main method, create touchedFile
+    }
+
+    if touchedFile.exists then
+      printf("success: script created file %s\n",touchedFile)
+    if touchedFile.exists then printf("success: created file %s\n",touchedFile)
+    assert( touchedFile.exists, s"expected to find file ${touchedFile}" )
+   
+  /*
+   * Compile touchFile.sc to create executable jar, verify jar execution succeeds.
+   */
+  @Test def scriptingNoCompileJar =
+    val scriptFile = touchFileScript
+    showScriptUnderTest(scriptFile)
+    val expectedJar = script2jar(scriptFile)
+    sys.props("script.path") = scriptFile.absPath
+    val mainArgs: Array[String] = Array(
+      "-classpath", TestConfiguration.basicClasspath.toString,
+      "-save",
+      "-script", scriptFile.toString,
+      "-compile-only"
+    )
+
+    expectedJar.delete
+    Main.main(mainArgs) // create executable jar
+    printf("===> test script jar name [%s]\n",expectedJar.getName)
+    assert(expectedJar.exists,s"unable to create executable jar [$expectedJar]")
+
+    touchedFile.delete
+    assert(!touchedFile.exists,s"unable to delete ${touchedFile}")
+    printf("calling executable jar %s\n",expectedJar)
+    callExecutableJar(scriptFile, expectedJar)
+    if touchedFile.exists then
+      printf("success: executable jar created file %s\n",touchedFile)
+    assert( touchedFile.exists, s"expected to find file ${touchedFile}" )
+
+  def touchFileScript = testFiles.find(_.getName == "touchFile.sc").get
+  def touchedFile = File("touchedFile.out")

dist/bin/scala

@@ -53,6 +53,8 @@ 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)
@@ -73,7 +75,7 @@ while [[ $# -gt 0 ]]; do
       with_compiler=true
       shift
       ;;
-    @*|-color:*)
+    @*|-color:*|-compile-only)
       addDotcOptions "${1}"
       shift
       ;;
@@ -113,12 +115,6 @@ if [ $execute_script == true ]; then
   if [ "$CLASS_PATH" ]; then
     cp_arg="-classpath \"$CLASS_PATH\""
   fi
-  if [ -n "$SCALA_OPTS" ]; then
-    java_options+=($SCALA_OPTS)
-    if [ "${SCALA_OPTS##*-save}" != "${SCALA_OPTS}" ]; then
-      save_compiled=true
-    fi
-  fi
   setScriptName="-Dscript.path=$target_script"
   target_jar="${target_script%.*}.jar"
   if [[ $save_compiled == true && "$target_jar" -nt "$target_script" ]]; then