Find main classes in jars from -classpath

Author: Gedochao

modules/build/src/main/scala/scala/build/internal/MainClass.scala

@@ -3,6 +3,12 @@ package scala.build.internal
 import org.objectweb.asm
 import org.objectweb.asm.ClassReader
 
+import java.io.{ByteArrayInputStream, InputStream}
+import java.util.zip.ZipEntry
+
+import scala.build.Inputs.{Element, resolve}
+import scala.build.internal.zip.WrappedZipInputStream
+
 object MainClass {
 
   private def stringArrayDescriptor = "([Ljava/lang/String;)V"
@@ -37,26 +43,45 @@ object MainClass {
       if (foundMainClass) nameOpt else None
   }
 
-  def findInClass(path: os.Path): Iterator[String] = {
-    val is = os.read.inputStream(path)
+  def findInClass(path: os.Path): Iterator[String] =
+    findInClass(os.read.inputStream(path))
+  def findInClass(is: InputStream): Iterator[String] =
     try {
       val reader  = new ClassReader(is)
       val checker = new MainMethodChecker
       reader.accept(checker, 0)
       checker.mainClassOpt.iterator
     }
     finally is.close()
+
+  def findInJar(path: os.Path): Iterator[String] = {
+    val content        = os.read.bytes(path)
+    val jarInputStream = WrappedZipInputStream.create(new ByteArrayInputStream(content))
+    jarInputStream.entries().flatMap(ent =>
+      if !ent.isDirectory && ent.getName.endsWith(".class") then {
+        val content     = jarInputStream.readAllBytes()
+        val inputStream = new ByteArrayInputStream(content)
+        findInClass(inputStream)
+      }
+      else Iterator.empty
+    )
   }
+
   def find(output: os.Path): Seq[String] =
     output match {
       case o if os.isFile(o) && o.last.endsWith(".class") =>
         findInClass(o).toVector
+      case o if os.isFile(o) && o.last.endsWith(".jar") =>
+        findInJar(o).toVector
       case o if os.isDir(o) =>
         os.walk(o)
           .iterator
-          .filter(os.isFile(_))
-          .filter(_.last.endsWith(".class"))
-          .flatMap(findInClass)
+          .filter(os.isFile)
+          .flatMap {
+            case classFilePath if classFilePath.last.endsWith(".class") =>
+              findInClass(classFilePath)
+            case _ => Iterator.empty
+          }
           .toVector
       case _ => Vector.empty
     }

modules/cli/src/main/scala/scala/cli/commands/Default.scala

@@ -35,7 +35,7 @@ class Default(
         val shouldDefaultToRun =
           args.remaining.nonEmpty || options.shared.snippet.executeScript.nonEmpty ||
           options.shared.snippet.executeScala.nonEmpty || options.shared.snippet.executeJava.nonEmpty ||
-          (options.shared.extraJarsAndClasspath.nonEmpty && options.sharedRun.mainClass.mainClass.nonEmpty)
+          (options.shared.extraJarsAndClassPath.nonEmpty && options.sharedRun.mainClass.mainClass.nonEmpty)
         if shouldDefaultToRun then RunOptions.parser else ReplOptions.parser
       }.parse(rawArgs) match
         case Left(e)                              => error(e)

modules/cli/src/main/scala/scala/cli/commands/util/SharedOptionsUtil.scala

@@ -8,6 +8,7 @@ import dependency.AnyDependency
 import dependency.parser.DependencyParser
 
 import java.io.{File, InputStream}
+import java.nio.file.Paths
 
 import scala.build.EitherCps.{either, value}
 import scala.build.*
@@ -213,14 +214,8 @@ object SharedOptionsUtil extends CommandHelpers {
           runJmh = if (enableJmh) Some(true) else None
         ),
         classPathOptions = bo.ClassPathOptions(
-          extraClassPath = extraJarsAndClasspath
-            .flatMap(_.split(File.pathSeparator).toSeq)
-            .filter(_.nonEmpty)
-            .map(os.Path(_, os.pwd)),
-          extraCompileOnlyJars = extraCompileOnlyJars
-            .flatMap(_.split(File.pathSeparator).toSeq)
-            .filter(_.nonEmpty)
-            .map(os.Path(_, os.pwd)),
+          extraClassPath = extraJarsAndClassPath,
+          extraCompileOnlyJars = extraCompileOnlyClassPath,
           extraRepositories = dependencies.repository.map(_.trim).filter(_.nonEmpty),
           extraDependencies = ShadowingSeq.from(
             SharedOptionsUtil.parseDependencies(
@@ -242,8 +237,28 @@ object SharedOptionsUtil extends CommandHelpers {
       )
     }
 
-    def extraJarsAndClasspath: List[String] =
-      extraJars ++ scalac.scalacOption.toScalacOptShadowingSeq.getScalacOption("-classpath")
+    extension (rawClassPath: List[String]) {
+      def extractedClassPath: List[os.Path] =
+        rawClassPath
+          .flatMap(_.split(File.pathSeparator).toSeq)
+          .filter(_.nonEmpty)
+          .distinct
+          .map(os.Path(_, os.pwd))
+          .flatMap {
+            case cp if os.isDir(cp) =>
+              val jarsInTheDirectory =
+                os.walk(cp)
+                  .filter(p => os.isFile(p) && p.last.endsWith(".jar"))
+              List(cp) ++ jarsInTheDirectory // .jar paths have to be passed directly, unlike .class
+            case cp => List(cp)
+          }
+    }
+
+    def extraJarsAndClassPath: List[os.Path] =
+      (extraJars ++ scalac.scalacOption.toScalacOptShadowingSeq.getScalacOption("-classpath"))
+        .extractedClassPath
+
+    def extraCompileOnlyClassPath: List[os.Path] = extraCompileOnlyJars.extractedClassPath
 
     def globalInteractiveWasSuggested: Option[Boolean] =
       configDb.get(Keys.globalInteractiveWasSuggested) match {
@@ -380,7 +395,7 @@ object SharedOptionsUtil extends CommandHelpers {
         scalaSnippetList = allScalaSnippets,
         javaSnippetList = allJavaSnippets,
         enableMarkdown = v.markdown.enableMarkdown,
-        extraClasspathWasPassed = v.extraJarsAndClasspath.nonEmpty
+        extraClasspathWasPassed = v.extraJarsAndClassPath.nonEmpty
       )
 
     def allScriptSnippets: List[String] = v.snippet.scriptSnippet ++ v.snippet.executeScript

modules/integration/src/test/scala/scala/cli/integration/RunTestDefinitions.scala

@@ -2341,6 +2341,65 @@ abstract class RunTestDefinitions(val scalaVersionOpt: Option[String])
     }
   }
 
+  test("run main class from a jar even when no explicit inputs are passed") {
+    val expectedOutput = "Hello"
+    TestInputs(
+      os.rel / "Main.scala" -> s"""object Main extends App { println("$expectedOutput") }"""
+    ).fromRoot { (root: os.Path) =>
+      // first, package the code to a jar with a main class
+      val jarPath = os.rel / "Main.jar"
+      os.proc(
+        TestUtil.cli,
+        "package",
+        ".",
+        "--library",
+        "-o",
+        jarPath,
+        extraOptions
+      ).call(cwd = root)
+
+      // next, run while relying on the jar instead of passing inputs
+      val runRes = os.proc(
+        TestUtil.cli,
+        "run",
+        "-classpath",
+        jarPath,
+        extraOptions
+      ).call(cwd = root)
+      expect(runRes.out.trim == expectedOutput)
+    }
+  }
+
+  test("run main class from a jar in a directory even when no explicit inputs are passed") {
+    val expectedOutput = "Hello"
+    TestInputs(
+      os.rel / "Main.scala" -> s"""object Main extends App { println("$expectedOutput") }"""
+    ).fromRoot { (root: os.Path) =>
+      // first, package the code to a jar with a main class
+      val jarParentDirectory = os.rel / "out"
+      val jarPath            = jarParentDirectory / "Main.jar"
+      os.proc(
+        TestUtil.cli,
+        "package",
+        ".",
+        "--library",
+        "-o",
+        jarPath,
+        extraOptions
+      ).call(cwd = root)
+
+      // next, run while relying on the jar instead of passing inputs
+      val runRes = os.proc(
+        TestUtil.cli,
+        "run",
+        "-classpath",
+        jarParentDirectory,
+        extraOptions
+      ).call(cwd = root)
+      expect(runRes.out.trim == expectedOutput)
+    }
+  }
+
   if (actualScalaVersion.startsWith("3"))
     test("should throw exception for code compiled by scala 3.1.3") {
       val exceptionMsg = "Throw exception in Scala"