Fix making executable JARs from scala compiler output

Author: BarkingBad

.gitignore

@@ -101,4 +101,4 @@ community-build/dotty-community-build-deps
 cs
 
 # Coursier test product
-compiler/test-coursier/run/myfile.jar
+compiler/test-coursier/run/*.jar

compiler/src/dotty/tools/MainGenericRunner.scala

@@ -149,19 +149,11 @@ object MainGenericRunner {
         val res = ObjectRunner.runAndCatch(newClasspath, settings.residualArgs.head, settings.residualArgs.drop(1)).flatMap {
           case ex: ClassNotFoundException if ex.getMessage == settings.residualArgs.head =>
             val file = settings.residualArgs.head
-            def withJarInput[T](f: JarInputStream => T): T =
-              val in = new JarInputStream(java.io.FileInputStream(file))
-              try f(in)
-              finally in.close()
-            val manifest = withJarInput(s => Option(s.getManifest))
-            manifest match
-              case None => Some(IllegalArgumentException(s"Cannot find manifest in jar: $file"))
-              case Some(f) =>
-                f.getMainAttributes.get(Name.MAIN_CLASS) match
-                  case mainClass: String =>
-                    ObjectRunner.runAndCatch(newClasspath :+ File(file).toURI.toURL, mainClass, settings.residualArgs)
-                  case _ =>
-                    Some(IllegalArgumentException(s"No main class defined in manifest in jar: $file"))
+            Jar(file).mainClass match
+              case Some(mc) =>
+                ObjectRunner.runAndCatch(newClasspath :+ File(file).toURI.toURL, mc, settings.residualArgs)
+              case None =>
+                Some(IllegalArgumentException(s"No main class defined in manifest in jar: $file"))
           case ex => Some(ex)
         }
         errorFn("", res)

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -83,8 +83,6 @@ class GenBCode extends Phase {
           val sym = tree.symbol
           import dotty.tools.dotc.core.NameOps.stripModuleClassSuffix
           val name = sym.fullName.stripModuleClassSuffix.toString
-            // We strip module class suffix. Zinc relies on a class and its companion having the same name
-
           if (sym.isStatic && !sym.is(Flags.Trait) && ctx.platform.hasMainMethod(sym)) {
             // If sym is an object, all main methods count, otherwise only @static ones count.
             _mainClassesBuffer += name
@@ -103,17 +101,11 @@ class GenBCode extends Phase {
     }
 
     mainClass.map { mc =>
-      import scala.util.Properties._
-      import java.util.jar._
-      import Attributes.Name._
-      val manifest = new Manifest
-      val attrs = manifest.getMainAttributes
-      attrs.put(MANIFEST_VERSION, "1.0")
-      attrs.put(ScalaCompilerVersion, versionNumberString)
-      attrs.put(MAIN_CLASS, mc)
+      val manifest = Jar.WManifest()
+      manifest.mainClass = mc
       val file = jarArchive.subdirectoryNamed("META-INF").fileNamed("MANIFEST.MF")
       val os = file.output
-      manifest.write(os)
+      manifest.underlying.write(os)
       os.close()
     }
   end updateJarManifestWithMainClass

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

@@ -44,7 +44,7 @@ class Jar(file: File) {
   import Jar._
 
   lazy val jarFile: JarFile  = new JarFile(file.jpath.toFile)
-  lazy val manifest: Option[Manifest] = withJarInput(s => Option(s.getManifest))
+  lazy val manifest: Option[Manifest] = withJarInput(s => Option(s.getManifest).orElse(findManifest(s)))
 
   def mainClass: Option[String]     = manifest.map(_(Name.MAIN_CLASS))
   /** The manifest-defined classpath String if available. */
@@ -72,6 +72,21 @@ class Jar(file: File) {
     case null   => errorFn("No such entry: " + entry) ; null
     case x      => x
   }
+
+  /**
+   * Hack for Java reading MANIFEST.MF only if it is at the first entry of the JAR file and otherwise returns null.
+   * https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/jar/JarInputStream.java#L74
+   * Suprisingly, such jars still can be successfully runned jars via `java -jar path.jar` so it is only problem for Jar readers.
+   */
+  private def findManifest(s: JarInputStream): Option[Manifest] =
+    val entry = s.getNextEntry
+    if entry != null && entry.getName != JarFile.MANIFEST_NAME then
+      findManifest(s)
+    else if entry == null then
+      None
+    else
+      Some(Manifest(s))
+
   override def toString: String = "" + file
 }
 

compiler/test-coursier/dotty/tools/coursier/CoursierScalaTests.scala

@@ -37,7 +37,7 @@ class CoursierScalaTests:
       val testScriptArgs = Seq("a", "b", "c", "-repl", "-run", "-script", "-debug")
 
       val args = scriptPath +: testScriptArgs
-      val output = CoursierScalaTests.csCmd(args*)
+      val output = CoursierScalaTests.csScalaCmd(args*)
       val expectedOutput = List(
         "arg  0:[a]",
         "arg  1:[b]",
@@ -55,49 +55,68 @@ class CoursierScalaTests:
     def scriptPath() =
       val scriptPath = scripts("/scripting").find(_.getName == "scriptPath.sc").get.absPath
       val args = scriptPath
-      val output = CoursierScalaTests.csCmd(args)
+      val output = CoursierScalaTests.csScalaCmd(args)
       assertTrue(output.mkString("\n").startsWith("script.path:"))
       assertTrue(output.mkString("\n").endsWith("scriptPath.sc"))
     scriptPath()
 
     def version() =
-      val output = CoursierScalaTests.csCmd("-version")
+      val output = CoursierScalaTests.csScalaCmd("-version")
       assertTrue(output.mkString("\n").contains(sys.env("DOTTY_BOOTSTRAPPED_VERSION")))
     version()
 
     def emptyArgsEqualsRepl() =
-      val output = CoursierScalaTests.csCmd()
+      val output = CoursierScalaTests.csScalaCmd()
       assertTrue(output.mkString("\n").contains("Unable to create a system terminal")) // Scala attempted to create REPL so we can assume it is working
     emptyArgsEqualsRepl()
 
     def run() =
-      val output = CoursierScalaTests.csCmd("-run", "-classpath", scripts("/run").head.getParentFile.getParent, "run.myfile")
+      val output = CoursierScalaTests.csScalaCmd("-run", "-classpath", scripts("/run").head.getParentFile.getParent, "run.myfile")
       assertEquals(output.mkString("\n"), "Hello")
     run()
 
     def notOnlyOptionsEqualsRun() =
-      val output = CoursierScalaTests.csCmd("-classpath", scripts("/run").head.getParentFile.getParent, "run.myfile")
+      val output = CoursierScalaTests.csScalaCmd("-classpath", scripts("/run").head.getParentFile.getParent, "run.myfile")
       assertEquals(output.mkString("\n"), "Hello")
     notOnlyOptionsEqualsRun()
 
     def help() =
-      val output = CoursierScalaTests.csCmd("-help")
+      val output = CoursierScalaTests.csScalaCmd("-help")
       assertTrue(output.mkString("\n").contains("Usage: scala <options> <source files>"))
     help()
 
     def jar() =
       val source = new File(getClass.getResource("/run/myfile.scala").getPath)
-      val output = CoursierScalaTests.csCmd("-save", source.absPath)
+      val output = CoursierScalaTests.csScalaCmd("-save", source.absPath)
       assertEquals(output.mkString("\n"), "Hello")
       assertTrue(source.getParentFile.listFiles.find(_.getName == "myfile.jar").isDefined)
     jar()
 
     def runThatJar() =
       val source = new File(getClass.getResource("/run/myfile.jar").getPath)
-      val output = CoursierScalaTests.csCmd(source.absPath)
+      val output = CoursierScalaTests.csScalaCmd(source.absPath)
       assertEquals(output.mkString("\n"), "Hello")
     runThatJar()
 
+    def compileFilesToJarAndRun() =
+      val source = new File(getClass.getResource("/run/myfile.scala").getPath)
+      val prefix = source.getParent
+
+      val o1source = Paths.get(prefix, "automain.jar").toAbsolutePath.toString
+      val output1 = CoursierScalaTests.csScalaCompilerCmd("-d", o1source, source.absPath)
+      assertEquals(output1.mkString("\n"), "")
+
+      val o2source = Paths.get(prefix, "custommain.jar").toAbsolutePath.toString
+      val output2 = CoursierScalaTests.csScalaCompilerCmd("-d", o2source, "-Xmain-class", "run.myfile", source.absPath)
+      assertEquals(output2.mkString("\n"), "")
+
+      val output3 = CoursierScalaTests.csScalaCmd(o1source)
+      assertEquals(output3.mkString("\n"), "Hello")
+
+      val output4 = CoursierScalaTests.csScalaCmd(o2source)
+      assertEquals(output4.mkString("\n"), "Hello")
+    compileFilesToJarAndRun()
+
 object CoursierScalaTests:
 
   def execCmd(command: String, options: String*): List[String] =
@@ -106,11 +125,17 @@ object CoursierScalaTests:
     cmd.!(ProcessLogger(out += _, out += _))
     out.toList
 
-  def csCmd(options: String*): List[String] =
+  def csScalaCmd(options: String*): List[String] =
+    csCmd("dotty.tools.MainGenericRunner", options*)
+
+  def csScalaCompilerCmd(options: String*): List[String] =
+    csCmd("dotty.tools.dotc.Main", options*)
+
+  private def csCmd(entry: String, options: String*): List[String] =
     val newOptions = options match
       case Nil => options
       case _ => "--" +: options
-    execCmd("./cs", (s"""launch "org.scala-lang:scala3-compiler_3:${sys.env("DOTTY_BOOTSTRAPPED_VERSION")}" --main-class "dotty.tools.MainGenericRunner" --property "scala.usejavacp=true"""" +: newOptions)*)
+    execCmd("./cs", (s"""launch "org.scala-lang:scala3-compiler_3:${sys.env("DOTTY_BOOTSTRAPPED_VERSION")}" --main-class "$entry" --property "scala.usejavacp=true"""" +: newOptions)*)
 
   /** Get coursier script */
   @BeforeClass def setup(): Unit =