Implement new main annotation

tests/neg/main-annotation-by-name-param.scala

@@ -0,0 +1,17 @@
+object myProgram:
+
+  /** Adds two numbers */
+  @main def add(num: Int, inc: => Int): Unit =  // error
+    println(s"$num + $inc = ${num + inc}")
+
+end myProgram
+
+object Test:
+  def callMain(args: Array[String]): Unit =
+    val clazz = Class.forName("add")
+    val method = clazz.getMethod("main", classOf[Array[String]])
+    method.invoke(null, args)
+
+  def main(args: Array[String]): Unit =
+    callMain(Array("2", "3"))
+end Test

tests/neg/main-annotation-currying.scala

@@ -0,0 +1,8 @@
+import scala.annotation.newMain
+
+object myProgram:
+
+  @newMain def add(num: Int)(inc: Int): Unit = // error
+    println(s"$num + $inc = ${num + inc}")
+
+end myProgram

tests/neg/main-annotation-generic.scala

@@ -0,0 +1,8 @@
+import scala.annotation.newMain
+
+object myProgram:
+
+  @newMain def nop[T](t: T): T = // error
+    t
+
+end myProgram

tests/neg/main-annotation-implicit-given.scala

@@ -0,0 +1,13 @@
+import scala.annotation.newMain
+
+object myProgram:
+  implicit val x: Int = 2
+  given Int = 3
+
+  @newMain def showImplicit(implicit num: Int): Unit = // error
+    println(num)
+
+  @newMain def showUsing(using num: Int): Unit = // error
+    println(num)
+
+end myProgram

tests/neg/main-annotation-multiple-annot.scala

@@ -0,0 +1,8 @@
+import scala.annotation.newMain
+
+object myProgram:
+
+  @newMain @newMain def add1(num: Int, inc: Int): Unit = // error
+    println(s"$num + $inc = ${num + inc}")
+
+end myProgram

tests/neg/main-annotation-nonmethod.scala

@@ -0,0 +1,11 @@
+import scala.annotation.newMain
+
+object myProgram:
+
+  @newMain val n = 2 // error
+
+  @newMain class A // error
+
+  @newMain val f = ((s: String) => println(s)) // error
+
+end myProgram

tests/neg/main-annotation-nonstatic.scala

@@ -0,0 +1,4 @@
+import scala.annotation.newMain
+
+class A:
+  @newMain def foo(bar: Int) = () // error

tests/neg/main-annotation-unknown-parser-1.scala

@@ -0,0 +1,12 @@
+import scala.annotation.newMain
+
+class MyNumber(val value: Int) {
+  def +(other: MyNumber): MyNumber = MyNumber(value + other.value)
+}
+
+object myProgram:
+
+  @newMain def add(num: MyNumber, inc: MyNumber): Unit = // error
+    println(s"$num + $inc = ${num + inc}")
+
+end myProgram

tests/neg/main-annotation-unknown-parser-2.scala

@@ -0,0 +1,27 @@
+import scala.annotation.newMain
+import scala.util.CommandLineParser.FromString
+
+object myProgram:
+
+  @newMain def add(num: Test.MyNumber, inc: Test.MyNumber): Unit = // error
+    val numV = Test.value(num)
+    val incV = Test.value(inc)
+    println(s"$numV + $incV = ${numV + incV}")
+
+end myProgram
+
+
+object Test:
+  opaque type MyNumber = Int
+
+  def create(n: Int): MyNumber = n
+  def value(n: MyNumber): Int = n
+
+  def callMain(args: Array[String]): Unit =
+    val clazz = Class.forName("add")
+    val method = clazz.getMethod("main", classOf[Array[String]])
+    method.invoke(null, args)
+
+  def main(args: Array[String]): Unit =
+    callMain(Array("2", "3"))
+end Test

tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala

@@ -32,6 +32,13 @@ val experimentalDefinitionInLibrary = Set(
   "scala.annotation.MainAnnotation",
   "scala.annotation.MainAnnotation$",
 
+  //// New feature: prototype of new version of @main
+  // This will never be stabilized. When it is ready it should replace the old @main annotation (requires scala.annotation.MainAnnotation).
+  // Needs user feedback.
+  "scala.annotation.newMain",
+  "scala.annotation.newMain$",
+  "scala.annotation.newMain$.alias",
+
   //// New APIs: Mirror
   // Can be stabilized in 3.3.0 or later.
   "scala.deriving.Mirror$.fromProductTyped", // This API is a bit convoluted. We may need some more feedback before we can stabilize it.

tests/run/main-annotation-birthday.check

@@ -0,0 +1 @@
+Happy 23rd birthday, Lisa and Peter

tests/run/main-annotation-birthday.scala

@@ -0,0 +1,32 @@
+import scala.annotation.newMain
+
+/**
+  * Wishes a happy birthday to lucky people!
+  *
+  * @param age the age of the people whose birthday it is
+  * @param name the name of the luckiest person!
+  * @param others all the other lucky people
+  */
+@newMain def happyBirthday(age: Int, name: String, others: String*) =
+  val suffix =
+    age % 100 match
+    case 11 | 12 | 13 => "th"
+    case _ =>
+      age % 10 match
+        case 1 => "st"
+        case 2 => "nd"
+        case 3 => "rd"
+        case _ => "th"
+  val bldr = new StringBuilder(s"Happy $age$suffix birthday, $name")
+  for other <- others do bldr.append(" and ").append(other)
+  println(bldr)
+
+object Test:
+  def callMain(args: Array[String]): Unit =
+    val clazz = Class.forName("happyBirthday")
+    val method = clazz.getMethod("main", classOf[Array[String]])
+    method.invoke(null, args)
+
+  def main(args: Array[String]): Unit =
+    callMain(Array("23", "Lisa", "Peter"))
+end Test

tests/run/main-annotation-dash-dash.check

@@ -0,0 +1,17 @@
+str = x
+rest = y,z
+
+str = x
+rest = y,z
+
+str = -a
+rest = x,y,z
+
+str = x
+rest = y,z
+
+str = y
+rest = z
+
+Error: missing argument for --str
+Usage: foo [--str] <String> [<String> [<String> [...]]]

tests/run/main-annotation-dash-dash.scala

@@ -0,0 +1,25 @@
+import scala.annotation.newMain
+
+object myProgram:
+
+  @newMain def foo(str: String, rest: String*): Unit =
+    println(s"str = $str")
+    println(s"rest = ${rest.mkString(",")}")
+    println()
+
+end myProgram
+
+object Test:
+  def callMain(args: Array[String]): Unit =
+    val clazz = Class.forName("foo")
+    val method = clazz.getMethod("main", classOf[Array[String]])
+    method.invoke(null, args)
+
+  def main(args: Array[String]): Unit =
+    callMain(Array("x", "y", "z"))
+    callMain(Array("--", "x", "y", "z"))
+    callMain(Array("--", "-a", "x", "y", "z"))
+    callMain(Array("x", "--", "y", "z"))
+    callMain(Array("--str", "y", "--", "z"))
+    callMain(Array("--str", "--", "y", "z")) // missing argument for `--str`
+end Test

tests/run/main-annotation-default-value-1.check

@@ -0,0 +1,3 @@
+2 + 3 = 5
+2 + 1 = 3
+0 + 1 = 1

tests/run/main-annotation-default-value-1.scala

@@ -0,0 +1,22 @@
+import scala.annotation.newMain
+
+// Sample main method
+object myProgram:
+
+  /** Adds two numbers */
+  @newMain def add(num: Int = 0, inc: Int = 1): Unit =
+    println(s"$num + $inc = ${num + inc}")
+
+end myProgram
+
+object Test:
+  def callMain(args: Array[String]): Unit =
+    val clazz = Class.forName("add")
+    val method = clazz.getMethod("main", classOf[Array[String]])
+    method.invoke(null, args)
+
+  def main(args: Array[String]): Unit =
+    callMain(Array("2", "3"))
+    callMain(Array("2"))
+    callMain(Array())
+end Test

tests/run/main-annotation-default-value-2.check

@@ -0,0 +1,2 @@
+42
+OK

tests/run/main-annotation-default-value-2.scala

@@ -0,0 +1,33 @@
+import scala.annotation.newMain
+
+// Sample main method
+object myProgram:
+
+  @newMain def alwaysPassParam(forbiddenParam: Int = throw new IllegalStateException("This should not be evaluated!")): Unit =
+    println(forbiddenParam)
+
+end myProgram
+
+object Test:
+  def hasCauseIllegalStateException(e: Throwable): Boolean =
+    e.getCause match {
+      case null => false
+      case _: IllegalStateException => true
+      case e: Throwable => hasCauseIllegalStateException(e)
+    }
+
+  def callMain(args: Array[String]): Unit =
+    val clazz = Class.forName("alwaysPassParam")
+    val method = clazz.getMethod("main", classOf[Array[String]])
+    method.invoke(null, args)
+
+  def main(args: Array[String]): Unit =
+    callMain(Array("42"))
+    try {
+      callMain(Array())
+      println("This should not be printed")
+    }
+    catch {
+      case e: Exception if hasCauseIllegalStateException(e) => println("OK")
+    }
+end Test

tests/run/main-annotation-flags.check

@@ -0,0 +1,16 @@
+shortFlags: a = false, b = false
+shortFlags: a = true, b = false
+shortFlags: a = true, b = true
+Error: unused argument: true
+Error: unused argument: false
+Usage: shortFlags [-a] [-b]
+Error: unused argument: true
+Usage: shortFlags [-a] [-b]
+Error: unused argument: true
+Usage: shortFlags [-a] [-b]
+longFlags: flag1 = false, flag2 = false
+longFlags: flag1 = true, flag2 = false
+longFlags: flag1 = true, flag2 = true
+mixedFlags: a = false, flag = false
+mixedFlags: a = true, flag = false
+mixedFlags: a = true, flag = true

tests/run/main-annotation-flags.scala

@@ -0,0 +1,41 @@
+import scala.annotation.newMain
+
+// Sample main method
+object myProgram:
+
+  @newMain def shortFlags(a: Boolean, b: Boolean): Unit =
+    println(s"shortFlags: a = $a, b = $b")
+
+  @newMain def longFlags(flag1: Boolean, flag2: Boolean): Unit =
+    println(s"longFlags: flag1 = $flag1, flag2 = $flag2")
+
+  @newMain def mixedFlags(a: Boolean, flag: Boolean): Unit =
+    println(s"mixedFlags: a = $a, flag = $flag")
+
+end myProgram
+
+object Test:
+  def callMain(name: String, args: String*): Unit =
+    val clazz = Class.forName(name)
+    val method = clazz.getMethod("main", classOf[Array[String]])
+    method.invoke(null, args.toArray)
+
+  def main(args: Array[String]): Unit =
+    callMain("shortFlags")
+    callMain("shortFlags", "-a")
+    callMain("shortFlags", "-a", "-b")
+    callMain("shortFlags", "true", "false")
+    callMain("shortFlags", "-a", "true")
+    callMain("shortFlags", "-b", "true")
+
+
+    callMain("longFlags")
+    callMain("longFlags", "--flag1")
+    callMain("longFlags", "--flag1", "--flag2")
+
+    callMain("mixedFlags")
+    callMain("mixedFlags", "-a")
+    callMain("mixedFlags", "-a", "--flag")
+
+
+end Test