added missing shift in new -classpath* case in dist/bin/scala; fixed various style errors

Author: philwalk

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

@@ -10,7 +10,7 @@ object Main:
       All arguments afterwards are script arguments.*/
   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(",")})")
+    assert(rest.size >= 2, s"internal error: rest == Array(${rest.mkString(",")})")
 
     val file = File(rest(1))
     val scriptArgs = rest.drop(2)
@@ -91,7 +91,7 @@ object Main:
     // convert to absolute path relative to cwd.
     def absPath: String = norm match
       case str if str.isAbsolute => norm
-      case _ => Paths.get(userDir,norm).toString.norm
+      case _ => Paths.get(userDir, norm).toString.norm
 
     def toUrl: String = Paths.get(absPath).toUri.toURL.toString
 

compiler/test-resources/scripting/classpathReport.sc

@@ -3,7 +3,7 @@
 import java.nio.file.Paths
 
 def main(args: Array[String]): Unit =
-  val cwd = Paths.get(".").toAbsolutePath.toString.replace('\\','/').replaceAll("/$","")
-  printf("cwd: %s\n",cwd)
-  printf("classpath: %s\n",sys.props("java.class.path"))
+  val cwd = Paths.get(".").toAbsolutePath.toString.replace('\\', '/').replaceAll("/$", "")
+  printf("cwd: %s\n", cwd)
+  printf("classpath: %s\n", sys.props("java.class.path"))
 

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

@@ -18,7 +18,7 @@ class ClasspathTests:
     str.reverse.dropWhile(_ != '.').drop(1).reverse
 
   extension(f: File) def absPath =
-    f.getAbsolutePath.replace('\\','/')
+    f.getAbsolutePath.replace('\\', '/')
 
   // only interested in classpath test scripts
   def testFiles = scripts("/scripting").filter { _.getName.matches("classpath.*[.]sc") }
@@ -36,21 +36,21 @@ class ClasspathTests:
    */
   @Test def scalacEchoTest =
     val relpath = testScript.toPath.relpath.norm
-    printf("===> scalacEchoTest for script [%s]\n",relpath)
-    printf("bash is [%s]\n",bashExe)
+    printf("===> scalacEchoTest for script [%s]\n", relpath)
+    printf("bash is [%s]\n", bashExe)
 
     if packBinScalaExists then
       val echoTest = "SCALAC_ECHO_TEST=1"
       val bashCmdline = s"SCALA_OPTS= $echoTest dist/target/pack/bin/scala -classpath '$wildcardEntry' $relpath"
 
       // ask [dist/bin/scalac] to echo generated command line so we can verify some things
-      val cmd = Array(bashExe,"-c",bashCmdline)
+      val cmd = Array(bashExe, "-c", bashCmdline)
 
-      //cmd.foreach { printf("[%s]\n",_) }
+      //cmd.foreach { printf("[%s]\n", _) }
 
       val javaCommandLine = exec(cmd:_*).mkString(" ").split(" ").filter { _.trim.nonEmpty }
-      printf("\n==================== isWin[%s], cygwin[%s], mingw[%s], msys[%s]\n",isWin,cygwin,mingw,msys)
-      javaCommandLine.foreach { printf("java-command[%s]\n",_) }
+      printf("\n==================== isWin[%s], cygwin[%s], mingw[%s], msys[%s]\n", isWin, cygwin, mingw, msys)
+      javaCommandLine.foreach { printf("java-command[%s]\n", _) }
 
       val output = scala.collection.mutable.Queue(javaCommandLine:_*)
       output.dequeueWhile( _ != "dotty.tools.scripting.Main")
@@ -63,54 +63,54 @@ class ClasspathTests:
 
       // display command line starting with "dotty.tools.scripting.Main"
       output.foreach { line =>
-        printf("%s\n",line)
+        printf("%s\n", line)
       }
 
       // expecting -classpath next
-      assert(consumeNext.replaceAll("'","") == "-classpath")
+      assert(consumeNext.replaceAll("'", "") == "-classpath")
 
       // 2nd arg to scripting.Main is 'lib/*', with semicolon added if Windows jdk
 
       // PR #10761: verify that [dist/bin/scala] -classpath processing adds $psep to wildcard if Windows
       val classpathValue = consumeNext
-      printf("classpath value [%s]\n",classpathValue)
+      printf("classpath value [%s]\n", classpathValue)
       assert( !winshell || classpathValue.contains(psep) )
 
       // expecting -script next
-      assert(consumeNext.replaceAll("'","") == "-script")
+      assert(consumeNext.replaceAll("'", "") == "-script")
 
       // PR #10761: verify that Windows jdk did not expand single wildcard classpath to multiple file paths
       if javaCommandLine.last != relpath then
-        printf("last: %s\nrelp: %s\n",javaCommandLine.last,relpath)
-        assert(javaCommandLine.last == relpath,s"unexpected output passed to scripting.Main")
+        printf("last: %s\nrelp: %s\n", javaCommandLine.last, relpath)
+        assert(javaCommandLine.last == relpath, s"unexpected output passed to scripting.Main")
 
   /*
    * verify classpath reported by called script.
    */
   @Test def hashbangClasspathVerifyTest =
     val relpath = testScript.toPath.relpath.norm
-    printf("===> hashbangClasspathVerifyTest for script [%s]\n",relpath)
-    printf("bash is [%s]\n",bashExe)
+    printf("===> hashbangClasspathVerifyTest for script [%s]\n", relpath)
+    printf("bash is [%s]\n", bashExe)
 
     if false && packBinScalaExists then
       val bashCmdline = s"SCALA_OPTS= $relpath"
-      val cmd = Array(bashExe,"-c",bashCmdline)
+      val cmd = Array(bashExe, "-c", bashCmdline)
 
-      cmd.foreach { printf("[%s]\n",_) }
+      cmd.foreach { printf("[%s]\n", _) }
 
       // test script reports the classpath it sees 
       val scriptOutput = exec(cmd:_*)
-      val scriptCwd = findTaggedLine("cwd",scriptOutput)
-      printf("script ran in directory [%s]\n",scriptCwd)
-      val scriptCp = findTaggedLine("classpath",scriptOutput)
+      val scriptCwd = findTaggedLine("cwd", scriptOutput)
+      printf("script ran in directory [%s]\n", scriptCwd)
+      val scriptCp = findTaggedLine("classpath", scriptOutput)
 
       val hashbangClasspathJars = scriptCp.split(psep).map { _.getName }.sorted.distinct
       val packlibJars = listJars(s"$scriptCwd/dist/target/pack/lib").sorted.distinct
 
       // verify that the classpath set in the hashbang line is effective
       if hashbangClasspathJars.size != packlibJars.size then
-        printf("%d test script jars in classpath\n",hashbangClasspathJars.size)
-        printf("%d jar files in dist/target/pack/lib\n",packlibJars.size)
+        printf("%d test script jars in classpath\n", hashbangClasspathJars.size)
+        printf("%d jar files in dist/target/pack/lib\n", packlibJars.size)
 
       assert(hashbangClasspathJars.size == packlibJars.size)
 
@@ -127,7 +127,7 @@ def listJars(dir: String) =
     Nil
 
 import scala.jdk.CollectionConverters._
-lazy val env:Map[String,String] = System.getenv.asScala.toMap
+lazy val env:Map[String, String] = System.getenv.asScala.toMap
 
 // script output expected as "<tag>: <value>"
 def findTaggedLine(tag: String, lines: Seq[String]): String =
@@ -161,7 +161,7 @@ def which(str:String) =
 
 def bashExe = which("bash")
 def unameExe = which("uname")
-def path = envOrElse("PATH","").split(psep).toList
+def path = envOrElse("PATH", "").split(psep).toList
 def psep = sys.props("path.separator")
 
 def cygwin = ostype == "cygwin"
@@ -174,10 +174,10 @@ def ostype = ostypeFull.toLowerCase.takeWhile{ cc => cc >= 'a' && cc <='z' || cc
 
 extension(p:Path)
   def relpath: Path = cwd.relativize(p)
-  def norm: String = p.toString.replace('\\','/')
+  def norm: String = p.toString.replace('\\', '/')
 
 extension(path: String)
-  def getName: String = norm.replaceAll(".*/","")
+  def getName: String = norm.replaceAll(".*/", "")
 
   // Normalize path separator, convert relative path to absolute
   def norm: String =
@@ -187,12 +187,12 @@ extension(path: String)
       case s => s
     }
 
-  def parent: String = norm.replaceAll("/[^/]*$","")
+  def parent: String = norm.replaceAll("/[^/]*$", "")
 
   // convert to absolute path relative to cwd.
   def absPath: String = norm match
     case str if str.isAbsolute => norm
-    case _ => Paths.get(userDir,norm).toString.norm
+    case _ => Paths.get(userDir, norm).toString.norm
 
   def isDir: Boolean = Files.isDirectory(Paths.get(path))
 

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

@@ -16,17 +16,17 @@ class ScriptingTests:
     str.reverse.dropWhile(_ != '.').drop(1).reverse
 
   extension(f: File) def absPath =
-    f.getAbsolutePath.replace('\\','/')
+    f.getAbsolutePath.replace('\\', '/')
 
   // classpath tests managed by scripting.ClasspathTests.scala
   def testFiles = scripts("/scripting").filter { ! _.getName.startsWith("classpath") }
 
   def script2jar(scriptFile: File) = 
     val jarName = s"${scriptFile.getName.dropExtension}.jar"
-    File(scriptFile.getParent,jarName)
+    File(scriptFile.getParent, jarName)
 
   def showScriptUnderTest(scriptFile: File): Unit =
-    printf("===> test script name [%s]\n",scriptFile.getName)
+    printf("===> test script name [%s]\n", scriptFile.getName)
 
   val argss: Map[String, Array[String]] = (
     for
@@ -42,11 +42,11 @@ class ScriptingTests:
       if scriptFile.getName.endsWith(extension)
       name = scriptFile.getName.dropExtension
       scriptArgs = argss.getOrElse(name, Array.empty[String])
-    yield scriptFile -> scriptArgs).toList.sortBy { (file,args) => file.getName }
+    yield scriptFile -> scriptArgs).toList.sortBy { (file, args) => file.getName }
 
-  def callExecutableJar(script: File,jar: File, scriptArgs: Array[String] = Array.empty[String]) = {
+  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)
+    val cmd = Array("java", s"-Dscript.path=${script.getName}", "-jar", jar.absPath)
       ++ scriptArgs
     Process(cmd).lazyLines_!.foreach { println }
   }
@@ -55,7 +55,7 @@ class ScriptingTests:
    * Call .scala scripts without -save option, verify no jar created
    */
   @Test def scriptingDriverTests =
-    for (scriptFile,scriptArgs) <- scalaFilesWithArgs(".scala") do
+    for (scriptFile, scriptArgs) <- scalaFilesWithArgs(".scala") do
       showScriptUnderTest(scriptFile)
       val unexpectedJar = script2jar(scriptFile)
       unexpectedJar.delete
@@ -67,8 +67,8 @@ class ScriptingTests:
         ),
         scriptFile = scriptFile,
         scriptArgs = scriptArgs
-      ).compileAndRun { (path:java.nio.file.Path,classpathEntries:Seq[Path], mainClass:String) =>
-        printf("mainClass from ScriptingDriver: %s\n",mainClass)
+      ).compileAndRun { (path:java.nio.file.Path, classpathEntries:Seq[Path], 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}")
@@ -77,7 +77,7 @@ class ScriptingTests:
    * Call .sc scripts without -save option, verify no jar created
    */
   @Test def scriptingMainTests =
-    for (scriptFile,scriptArgs) <- scalaFilesWithArgs(".sc") do
+    for (scriptFile, scriptArgs) <- scalaFilesWithArgs(".sc") do
       showScriptUnderTest(scriptFile)
       val unexpectedJar = script2jar(scriptFile)
       unexpectedJar.delete
@@ -95,7 +95,7 @@ class ScriptingTests:
    * Call .sc scripts with -save option, verify jar is created.
    */
   @Test def scriptingJarTest =
-    for (scriptFile,scriptArgs) <- scalaFilesWithArgs(".sc") do
+    for (scriptFile, scriptArgs) <- scalaFilesWithArgs(".sc") do
       showScriptUnderTest(scriptFile)
       val expectedJar = script2jar(scriptFile)
       expectedJar.delete
@@ -109,7 +109,7 @@ class ScriptingTests:
 
       Main.main(mainArgs)
 
-      printf("===> test script jar name [%s]\n",expectedJar.getName)
+      printf("===> test script jar name [%s]\n", expectedJar.getName)
       assert(expectedJar.exists)
 
       callExecutableJar(scriptFile, expectedJar, scriptArgs)
@@ -130,8 +130,8 @@ class ScriptingTests:
       compilerArgs = Array("-classpath", TestConfiguration.basicClasspath),
       scriptFile = scriptFile,
       scriptArgs = Array.empty[String]
-    ).compileAndRun { (path:java.nio.file.Path,classpathEntries:Seq[Path], mainClass:String) =>
-      printf("success: no call to main method in mainClass: %s\n",mainClass)
+    ).compileAndRun { (path:java.nio.file.Path, classpathEntries:Seq[Path], mainClass:String) =>
+      printf("success: no call to main method in mainClass: %s\n", mainClass)
       false // no call to compiled script main method
     }
     touchedFile.delete
@@ -143,14 +143,14 @@ class ScriptingTests:
       compilerArgs = Array("-classpath", TestConfiguration.basicClasspath),
       scriptFile = scriptFile,
       scriptArgs = Array.empty[String]
-    ).compileAndRun { (path:java.nio.file.Path,classpathEntries:Seq[Path], mainClass:String) =>
-      printf("call main method in mainClass: %s\n",mainClass)
+    ).compileAndRun { (path:java.nio.file.Path, classpathEntries:Seq[Path], 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)
+      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}" )
 
   /*
@@ -170,15 +170,15 @@ class ScriptingTests:
 
     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]")
+    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)
+    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)
+      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

dist/bin/scala

@@ -74,8 +74,8 @@ while [[ $# -gt 0 ]]; do
     -cp*|-classpath*)
       # hashbang can combine args, e.g. "-classpath 'lib/*'"
       CLASS_PATH="${1#* *}${PSEP}"
-      echo "CLASS_PATH[$CLASS_PATH]" 1>&2
       class_path_count+=1
+      shift
       ;;
     -with-compiler)
       with_compiler=true