add exit code tests, fix exit code for tastyprinter flag, improve temp file creation for expression for better error messages

Author: rochala

compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala

@@ -37,20 +37,22 @@ object TastyPrinter:
     for arg <- args do
       if arg == "-color:never" then () // skip
       else if arg.startsWith("-") then println(s"bad option '$arg' was ignored")
-      else if arg.endsWith(".tasty") then {
+      else if arg.endsWith(".tasty") then
         val path = Paths.get(arg)
-        if Files.exists(path) then printTasty(arg, Files.readAllBytes(path).nn)
-        else println("File not found: " + arg)
-      }
-      else if arg.endsWith(".jar") then {
+        if Files.exists(path) then
+          printTasty(arg, Files.readAllBytes(path).nn)
+        else
+          println("File not found: " + arg)
+          System.exit(1)
+      else if arg.endsWith(".jar") then
         val jar = JarArchive.open(Path(arg), create = false)
         try
           for file <- jar.iterator() if file.name.endsWith(".tasty") do
             printTasty(s"$arg ${file.path}", file.toByteArray)
         finally jar.close()
-
-      }
-      else println(s"Not a '.tasty' or '.jar' file: $arg")
+      else
+        println(s"Not a '.tasty' or '.jar' file: $arg")
+        System.exit(1)
 
     if printLastLine then
       println(line)

compiler/src/dotty/tools/io/Path.scala

@@ -170,7 +170,7 @@ class Path private[io] (val jpath: JPath) {
   // returns the filename without the extension.
   def stripExtension: String = name stripSuffix ("." + extension)
   // returns the Path with the extension.
-  def addExtension(ext: String): Path = new Path(jpath.resolveSibling(name + ext))
+  def addExtension(ext: String): Path = new Path(jpath.resolveSibling(name + "." + ext))
   // changes the existing extension out for a new one, or adds it
   // if the current path has none.
   def changeExtension(ext: String): Path =

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

@@ -43,11 +43,10 @@ object Main:
         // write a standalone jar to the script parent directory
         writeJarfile(outDir, scriptFile, scriptArgs, classpathEntries, mainClass)
       invokeFlag
-    } match
-      case Some(ex) =>
-        println(ex.getMessage)
-        sys.exit(1)
-      case _ =>
+    }.map {
+      case ScriptingException(msg) => println(msg)
+      case ex => ex.printStackTrace
+    }.foreach(_ => System.exit(1))
 
   private def writeJarfile(outDir: Path, scriptFile: File, scriptArgs:Array[String],
       classpathEntries:Seq[Path], mainClassName: String): Unit =

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

@@ -8,6 +8,7 @@ import dotty.tools.dotc.Driver
 import dotty.tools.dotc.core.Contexts, Contexts.{ Context, ctx }
 import dotty.tools.io.{ PlainDirectory, Directory, ClassPath }
 import Util.*
+import dotty.tools.dotc.util.SourceFile
 
 class StringDriver(compilerArgs: Array[String], scalaSource: String) extends Driver:
   override def sourcesRequired: Boolean = false
@@ -18,11 +19,12 @@ class StringDriver(compilerArgs: Array[String], scalaSource: String) extends Dri
 
     setup(compilerArgs, initCtx.fresh) match
       case Some((toCompile, rootCtx)) =>
-        given Context = rootCtx.fresh.setSetting(rootCtx.settings.outputDir,
-          new PlainDirectory(Directory(outDir)))
+        given Context = rootCtx.fresh.setSetting(rootCtx.settings.outputDir, new PlainDirectory(Directory(outDir)))
 
         val compiler = newCompiler
-        compiler.newRun.compileFromStrings(List(scalaSource))
+
+        val source = SourceFile.virtual("expression", scalaSource)
+        compiler.newRun.compileSources(List(source))
 
         val output = ctx.settings.outputDir.value
         if ctx.reporter.hasErrors then
@@ -39,7 +41,7 @@ class StringDriver(compilerArgs: Array[String], scalaSource: String) extends Dri
               case Left(ex) => Some(ex)
           catch
             case e: java.lang.reflect.InvocationTargetException =>
-              throw e.getCause
+              Some(e.getCause)
           finally
             deleteFile(outDir.toFile)
       case None => None

compiler/test-resources/scripting/compileError.scala

@@ -0,0 +1 @@
+@main def compileError = prin

compiler/test-resources/scripting/positiveTest.scala

@@ -0,0 +1 @@
+@main def positiveTest = println("Hello World!")

compiler/test-resources/scripting/runtimeError.scala

@@ -0,0 +1 @@
+@main def runtimeError = throw RuntimeException()

compiler/test-resources/scripting/scriptCompileError.sc

@@ -0,0 +1 @@
+@main def main = prin

compiler/test-resources/scripting/scriptPositive.sc

@@ -0,0 +1 @@
+@main def scriptPositive = println("Hello world!")

compiler/test-resources/scripting/scriptRuntimeError.sc

@@ -0,0 +1 @@
+@main def scriptRuntimeError = throw RuntimeException()

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

@@ -0,0 +1,156 @@
+package dotty
+package tools
+package scripting
+
+import java.io.File
+import java.nio.file.Files
+import org.junit.Test
+import org.junit.Assert.assertEquals
+
+import ScriptTestEnv.*
+
+
+object BashExitCodeTests:
+  def testFiles = scripts("/scripting")
+
+  /*
+   * Compiles the class checking exit code
+   *
+   * @param testName name of the test containing the extension
+   * @param expectedExitCode expected exit code from the output
+   * @param deleteTempDir if temporary directory created for compilation output should delete in this scope
+   *
+   * @return Created temporary directory
+   */
+  private def testCompilationExitCode(testName: String, expectedExitCode: Int, deleteTempDir: Boolean = false): File =
+    val temporaryDir = Files.createTempDirectory(testName)
+    assertTestExists(testName) { testFile =>
+      try {
+        val testFilePath = testFile.absPath
+        val commandline = (Seq(scalacPath, "-d", temporaryDir, testFilePath)).mkString(" ")
+        val (validTest, exitCode, _, _) = bashCommand(commandline)
+        if verifyValid(validTest) then
+          assertEquals(expectedExitCode, exitCode)
+      } finally {
+        if deleteTempDir then Util.deleteFile(temporaryDir.toFile)
+      }
+    }
+    temporaryDir.toFile
+
+  /*
+   * Runs the command and checks the exit code
+   *
+   * @param args arguments for command line
+   * @param expectedExitCode expected exit code from the output
+   */
+  private def testCommandExitCode(args: Seq[String], expectedExitCode: Int): Unit =
+    val commandline = args.mkString(" ")
+    val (validTest, exitCode, output, erroutput) = bashCommand(commandline)
+    if verifyValid(validTest) then
+      assertEquals(expectedExitCode, exitCode)
+
+
+  /* Compiles and then runs the code checking the exit code
+   *
+   * @param testFileName name of the test
+   * @param runExitCode expected exit code from the runner output
+   */
+  private def testCompileAndRun(testFileName: String, runExitCode: Int): Unit =
+    val outputDirectory = testCompilationExitCode(testFileName, 0)
+
+    def testRuntimeExitCode(className: String, expectedExitCode: Int): Unit =
+        val testClassFile = outputDirectory.files.find(_.getName == s"$className.class")
+        assert(testClassFile.isDefined)
+        val commandline = (Seq(scalaPath, "-classpath", outputDirectory.getAbsolutePath, className)).mkString(" ")
+        val (validTest, exitCode, o, e) = bashCommand(commandline)
+          if verifyValid(validTest) then
+            assertEquals(expectedExitCode, exitCode)
+
+    try {
+      val generatedClassName = testFileName.split('.').head
+      testRuntimeExitCode(generatedClassName,  runExitCode)
+    } finally {
+      Util.deleteFile(outputDirectory)
+    }
+
+  /*
+   * Checks if scripting test resources contains test with given `testName`
+   * And then runs function `test`
+   *
+   * @param testName name of the test containing the extension
+   * @param test check to be run on found test file
+   */
+  private def assertTestExists(testName: String)(test: File => Unit) =
+    val file = testFiles.find(_.getName == testName)
+    assert(file.isDefined)
+    test(file.get)
+
+class BashExitCodeTests:
+  import BashExitCodeTests.*
+
+  @Test def verifyExitCodeOnCompileError: Unit =
+    testCompilationExitCode("compileError.scala", 1, true)
+
+  @Test def verifyExitCodeOnRuntimeError: Unit =
+    testCompileAndRun("runtimeError.scala", 1)
+
+  @Test def verifyExitCode: Unit =
+    testCompileAndRun("positiveTest.scala", 0)
+
+  @Test def verifyExitCodeOnScriptError: Unit =
+    assertTestExists("scriptRuntimeError.sc") { file =>
+      testCommandExitCode(Seq(scalacPath, "-script", file.absPath), 1)
+    }
+
+  @Test def verifyExitCodeOnScriptErrorCompiler: Unit =
+    assertTestExists("scriptRuntimeError.sc") { file =>
+      testCommandExitCode(Seq(scalacPath, "-script", file.absPath), 1)
+    }
+
+  @Test def verifyExitCodeOnScript: Unit =
+    assertTestExists("scriptPositive.sc") { file =>
+      testCommandExitCode(Seq(scalaPath, file.absPath), 0)
+    }
+
+  @Test def verifyExitCodeOnScriptCompiler: Unit =
+    assertTestExists("scriptPositive.sc") { file =>
+      testCommandExitCode(Seq(scalacPath, "-script", file.absPath), 0)
+    }
+
+  @Test def verifyExitCodeOnDecompilation: Unit =
+    val testName = "positiveTest"
+    val outputDirectory = testCompilationExitCode(s"$testName.scala", 0)
+    val tastyFilePath =  outputDirectory.toPath.resolve(s"$testName.tasty").toString
+    testCommandExitCode(Seq(scalacPath, "-decompile", tastyFilePath), 0)
+
+  @Test def verifyExitCodeOnPrintTasty: Unit =
+    val testName = "positiveTest"
+    val outputDirectory = testCompilationExitCode(s"$testName.scala", 0)
+    val tastyFilePath =  outputDirectory.toPath.resolve(s"$testName.tasty").toString
+    testCommandExitCode(Seq(scalacPath, "-print-tasty", tastyFilePath), 0)
+
+  @Test def verifyExitCodeOnDecompilationFailure: Unit =
+    val tempFile = Files.createTempFile("temp-file", ".class").toFile
+    testCommandExitCode(Seq(scalacPath, "-decompile", "non-existing-file.tasty"), 1)
+    testCommandExitCode(Seq(scalacPath, "-decompile", tempFile.absPath), 1)
+    Util.deleteFile(tempFile)
+
+  @Test def verifyExitCodeOnPrintTastyFailure: Unit =
+    val tempFile = Files.createTempFile("temp-file", ".class").toFile
+    testCommandExitCode(Seq(scalacPath, "-print-tasty", "non-existing-file.tasty"), 1)
+    testCommandExitCode(Seq(scalacPath, "-print-tasty", tempFile.absPath), 1)
+    Util.deleteFile(tempFile)
+
+  @Test def verifyExitCodeOnExpressionCompileError: Unit =
+    testCommandExitCode(Seq(scalaPath, "-e", "'prinln(10*10)'"), 1)
+
+  @Test def verifyExitCodeOnExpressionRuntimeError: Unit =
+    testCommandExitCode(Seq(scalaPath, "-e", "'1/0'"), 1)
+
+  @Test def verifyExitCodeOnExpression: Unit =
+    testCommandExitCode(Seq(scalaPath, "-e", "'println(10*10)'"), 0)
+
+  @Test def verifyExitCodeOnInfo: Unit =
+    List("--help", "--version", "-Xplugin-list", "-Vphases").foreach { flag =>
+      testCommandExitCode(Seq(scalaPath, flag), 0)
+    }