improvement: Detect objects with main class in scripts

Prebiously, if user had a legacy script with main method then it would not be picked up at all. Now, when we detect the correct signature we try to run it.

The possibility of false positives is pretty low, since user would have to have their own String or Array types.

Author: tgodzik

modules/build/src/main/scala/scala/build/ScopedSources.scala

@@ -69,7 +69,7 @@ final case class ScopedSources(
       .map(_.wrap(codeWrapper))
 
     codeWrapper match {
-      case _: AppCodeWrapper.type if wrappedScripts.size > 1 =>
+      case _: AppCodeWrapper if wrappedScripts.size > 1 =>
         wrappedScripts.find(_.originalPath.exists(_._1.toString == "main.sc"))
           .foreach(_ => logger.diagnostic(WarningMessages.mainScriptNameClashesWithAppWrapper))
       case _ => ()

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

@@ -1,6 +1,6 @@
 package scala.build.internal
 
-case object AppCodeWrapper extends CodeWrapper {
+case class AppCodeWrapper(scalaVersion: String) extends CodeWrapper {
   override def mainClassObject(className: Name) = className
 
   def apply(
@@ -12,13 +12,18 @@ case object AppCodeWrapper extends CodeWrapper {
   ) = {
     val wrapperObjectName = indexedWrapperName.backticked
 
+    val mainObject = WrapperUtils.mainObjectInScript(scalaVersion, code)
+    val invokeMain = mainObject match {
+      case None       => ""
+      case Some(name) => s"\n$name.main(args)"
+    }
     val packageDirective =
       if (pkgName.isEmpty) "" else s"package ${AmmUtil.encodeScalaSourcePath(pkgName)}" + "\n"
     val top = AmmUtil.normalizeNewlines(
       s"""$packageDirective
          |
          |object $wrapperObjectName extends App {
-         |val scriptPath = \"\"\"$scriptPath\"\"\"
+         |val scriptPath = \"\"\"$scriptPath\"\"\"$invokeMain
          |""".stripMargin
     )
     val bottom = AmmUtil.normalizeNewlines(

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

@@ -1,11 +1,13 @@
 package scala.build.internal
 
+// import scala.meta.parsers.Parsed
+
 /** Script code wrapper that solves problem of deadlocks when using threads. The code is placed in a
   * class instance constructor, the created object is kept in 'mainObjectCode'.script to support
   * running interconnected scripts using Scala CLI <br> <br> Incompatible with Scala 2 - it uses
   * Scala 3 feature 'export'<br> Incompatible with native JS members - the wrapper is a class
   */
-case object ClassCodeWrapper extends CodeWrapper {
+case class ClassCodeWrapper(scalaVersion: String) extends CodeWrapper {
 
   override def mainClassObject(className: Name): Name =
     Name(className.raw ++ "_sc")
@@ -16,8 +18,15 @@ case object ClassCodeWrapper extends CodeWrapper {
     extraCode: String,
     scriptPath: String
   ) = {
+
+    val mainObject = WrapperUtils.mainObjectInScript(scalaVersion, code)
+
+    val mainInvocation = mainObject match
+      case None       => s"val _ = script.hashCode()"
+      case Some(name) => s"script.$name.main(args)"
+
     val name             = mainClassObject(indexedWrapperName).backticked
-    val wrapperClassName = Name(indexedWrapperName.raw ++ "$_").backticked
+    val wrapperClassName = scala.build.internal.Name(indexedWrapperName.raw ++ "$_").backticked
     val mainObjectCode =
       AmmUtil.normalizeNewlines(s"""|object $name {
                                     |  private var args$$opt0 = Option.empty[Array[String]]
@@ -33,7 +42,7 @@ case object ClassCodeWrapper extends CodeWrapper {
                                     |
                                     |  def main(args: Array[String]): Unit = {
                                     |    args$$set(args)
-                                    |    val _ = script.hashCode() // hashCode to clear scalac warning about pure expression in statement position
+                                    |    $mainInvocation // hashCode to clear scalac warning about pure expression in statement position
                                     |  }
                                     |}
                                     |

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

@@ -4,7 +4,7 @@ package scala.build.internal
   * or/and not using JS native prefer [[ClassCodeWrapper]], since it prevents deadlocks when running
   * threads from script
   */
-case object ObjectCodeWrapper extends CodeWrapper {
+case class ObjectCodeWrapper(scalaVersion: String) extends CodeWrapper {
 
   override def mainClassObject(className: Name): Name =
     Name(className.raw ++ "_sc")
@@ -15,12 +15,18 @@ case object ObjectCodeWrapper extends CodeWrapper {
     extraCode: String,
     scriptPath: String
   ) = {
+    val mainObject = WrapperUtils.mainObjectInScript(scalaVersion, code)
     val name               = mainClassObject(indexedWrapperName).backticked
     val aliasedWrapperName = name + "$$alias"
-    val funHashCodeMethod =
+    val realScript =
       if (name == "main_sc")
-        s"$aliasedWrapperName.alias.hashCode()" // https://github.com/VirtusLab/scala-cli/issues/314
-      else s"${indexedWrapperName.backticked}.hashCode()"
+        s"$aliasedWrapperName.alias" // https://github.com/VirtusLab/scala-cli/issues/314
+      else s"${indexedWrapperName.backticked}"
+
+    val funHashCodeMethod = mainObject match {
+      case None       => s"val _ = $realScript.hashCode()"
+      case Some(name) => s"$realScript.$name.main(args)"
+    }
     // We need to call hashCode (or any other method so compiler does not report a warning)
     val mainObjectCode =
       AmmUtil.normalizeNewlines(s"""|object $name {
@@ -34,7 +40,7 @@ case object ObjectCodeWrapper extends CodeWrapper {
                                     |  }
                                     |  def main(args: Array[String]): Unit = {
                                     |    args$$set(args)
-                                    |    val _ = $funHashCodeMethod // hashCode to clear scalac warning about pure expression in statement position
+                                    |    $funHashCodeMethod // hashCode to clear scalac warning about pure expression in statement position
                                     |  }
                                     |}
                                     |""".stripMargin)

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

@@ -0,0 +1,43 @@
+package scala.build.internal
+
+object WrapperUtils {
+
+  def mainObjectInScript(scalaVersion: String, code: String): Option[String] =
+    import scala.meta.*
+
+    val scriptDialect =
+      if scalaVersion.startsWith("3") then dialects.Scala3Future else dialects.Scala213Source3
+
+    given Dialect = scriptDialect.withAllowToplevelStatements(true).withAllowToplevelTerms(true)
+    val parsedCode = code.parse[Source] match
+      case Parsed.Success(Source(stats)) => stats
+      case _                             => Nil
+
+    // Check if there is a main function defined inside an object
+    def checkSignature(defn: Defn.Def) =
+      defn.paramClauseGroups match
+        case List(Member.ParamClauseGroup(
+              Type.ParamClause(Nil),
+              List(Term.ParamClause(
+                List(Term.Param(
+                  Nil,
+                  _: Term.Name,
+                  Some(Type.Apply.After_4_6_0(
+                    Type.Name("Array"),
+                    Type.ArgClause(List(Type.Name("String")))
+                  )),
+                  None
+                )),
+                None
+              ))
+            )) => true
+        case _ => false
+    parsedCode.collect {
+      case Defn.Object(_, objName, templ) =>
+        templ.body.stats.find {
+          case defn: Defn.Def =>
+            defn.name.value == "main" && checkSignature(defn)
+          case _ => false
+        }.map(_ => objName.value)
+    }.flatten.headOption
+}

modules/build/src/main/scala/scala/build/preprocessing/ScriptPreprocessor.scala

@@ -134,7 +134,7 @@ case object ScriptPreprocessor extends Preprocessor {
     (codeWrapper: CodeWrapper) =>
       if (containsMainAnnot) logger.diagnostic(
         codeWrapper match {
-          case _: AppCodeWrapper.type =>
+          case _: AppCodeWrapper =>
             WarningMessages.mainAnnotationNotSupported( /* annotationIgnored */ true)
           case _ => WarningMessages.mainAnnotationNotSupported( /* annotationIgnored */ false)
         }
@@ -165,16 +165,16 @@ case object ScriptPreprocessor extends Preprocessor {
 
     def objectCodeWrapperForScalaVersion =
       // AppObjectWrapper only introduces the 'main.sc' restriction when used in Scala 3, there's no gain in using it with Scala 3
-      if effectiveScalaVersion.startsWith("2") then AppCodeWrapper
-      else ObjectCodeWrapper
+      if effectiveScalaVersion.startsWith("2") then AppCodeWrapper(effectiveScalaVersion)
+      else ObjectCodeWrapper(effectiveScalaVersion)
 
     buildOptions.scriptOptions.forceObjectWrapper match {
       case Some(true) => objectCodeWrapperForScalaVersion
       case _ =>
         buildOptions.scalaOptions.platform.map(_.value) match {
           case Some(_: Platform.JS.type)                  => objectCodeWrapperForScalaVersion
-          case _ if effectiveScalaVersion.startsWith("2") => AppCodeWrapper
-          case _                                          => ClassCodeWrapper
+          case _ if effectiveScalaVersion.startsWith("2") => AppCodeWrapper(effectiveScalaVersion)
+          case _                                          => ClassCodeWrapper(effectiveScalaVersion)
         }
     }
   }

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

@@ -69,6 +69,42 @@ trait RunScriptTestDefinitions { _: RunTestDefinitions =>
     }
   }
 
+  test("main.sc has object") {
+    val message = "Hello"
+    val inputs = TestInputs(
+      os.rel / "main.sc" ->
+        s"""|
+            |object Main {
+            |  def main(args: Array[String]): Unit = println("$message")
+            |}
+            |""".stripMargin
+    )
+    inputs.fromRoot { root =>
+      val output = os.proc(TestUtil.cli, extraOptions, "main.sc").call(cwd =
+        root
+      ).out.trim()
+      expect(output == message)
+    }
+  }
+
+  test("main.sc has object with object wrapper") {
+    val message = "Hello"
+    val inputs = TestInputs(
+      os.rel / "main.sc" ->
+        s"""|//> using objectWrapper
+            |object Main {
+            |  def main(args: Array[String]): Unit = println("$message")
+            |}
+            |""".stripMargin
+    )
+    inputs.fromRoot { root =>
+      val output = os.proc(TestUtil.cli, extraOptions, "--power", "main.sc").call(cwd =
+        root
+      ).out.trim()
+      expect(output == message)
+    }
+  }
+
   if (actualScalaVersion.startsWith("3"))
     test("use method from main.sc file") {
       val message = "Hello"

project/deps.sc

@@ -117,7 +117,7 @@ object Deps {
     def jsoniterScala                     = "2.23.2"
     def jsoniterScalaJava8                = "2.13.5.2"
     def jsoup                             = "1.18.3"
-    def scalaMeta                         = "4.9.9"
+    def scalaMeta                         = "4.12.7"
     def scalaNative04                     = "0.4.17"
     def scalaNative05                     = "0.5.6"
     def scalaNative                       = scalaNative05
@@ -227,7 +227,7 @@ object Deps {
   def semanticDbJavac          = ivy"com.sourcegraph:semanticdb-javac:${Versions.javaSemanticdb}"
   def semanticDbScalac         = ivy"org.scalameta:::semanticdb-scalac:${Versions.scalaMeta}"
   def scalametaSemanticDbShared =
-    ivy"org.scalameta:semanticdb-shared_${Scala.scala213}:${Versions.scalaMeta}"
+    ivy"org.scalameta:semanticdb-shared_2.13:${Versions.scalaMeta}"
       .exclude("org.jline" -> "jline") // to prevent incompatibilities with GraalVM <23
       .exclude("com.lihaoyi" -> "sourcecode_2.13")
       .exclude("org.scala-lang.modules" -> "scala-collection-compat_2.13")