allow mainargs to work with scala-cli without the --objectWrapper flag

[benwbooth]

I would like to be able to use mainargs with scala-cli. Right now using mainargs with the @main annotation on a case class causes a compiler error due to the way scala-cli wraps the program code by default. A workaround is to run scala-cli with the --objectWrapper flag, which changes the way scala-cli wraps the program code to make it compatible, but doing so causes scala-cli to emit a warning message about the --objectWrapper flag being an unstable experimental feature. lt would be nice if the @main annotation could be reworked to support running in scala-cli without requiring the use of the --objectWrapper flag.

[benwbooth]

It looks like it works now. But I get this message:

[warn]  Annotation @main in .sc scripts is not supported, use .scala format instead

Here is my code:

#!/usr/bin/env -S scala-cli shebang
//> using dep "com.lihaoyi::mainargs:0.7.6"

import scala.Tuple.Union
import scala.language.implicitConversions
import mainargs.{main, arg, ParserForClass, Flag}

given [T, Tup <: Tuple](using ev: Union[Tup] <:< T): Conversion[Tup, Seq[T]] =
  tuple => tuple.toArray.asInstanceOf[Array[T]].toVector

@main(
  name = "Character Processor",
  doc = """A simple character processing utility.

           This tool processes a list of characters and converts them to 
           either uppercase or lowercase format. Characters can be provided
           as a comma-separated string.

           Examples:
             ./scalatest.sc --chars "hello,world"
             ./scalatest.sc -c "X,Y,Z" --uppercase
             ./scalatest.sc --help""".stripIndent
)
case class Config(
  @arg(
    short = 'c', 
    doc = """Characters to process as a comma-separated string.
             Each character will be processed individually.
             Default: "A,B,C" """.stripIndent
  )
  chars: String = "A,B,C",
  
  @arg(
    short = 'u', 
    doc = """Convert characters to uppercase instead of lowercase.
             When this flag is set, all characters will be converted
             to uppercase. Otherwise, they will be converted to lowercase.""".stripIndent
  )
  uppercase: Flag = Flag()
)

def run(config: Config): Unit =
  val charList = config.chars.split(",").map(_.trim)
  
  println(s"Processing ${charList.length} characters...")
  println(s"Mode: ${if config.uppercase.value then "UPPERCASE" else "lowercase"}")
  println("Results:")
  
  for ch <- charList do
    val processed = if config.uppercase.value then ch.toUpperCase else ch.toLowerCase
    println(s"  '$ch' -> '$processed'")

val config = mainargs.ParserForClass[Config].constructOrExit(args)
run(config)

[liuyic00]

scala-cli uses regular expressions to match @main. See the code here.
To bypass this warning, you can replace @main with

@`main`

Apart from the issue with scala-cli, maybe @main could be renamed to something like @withArgs, given that this annotation is not only used on the entry point of the program but also on case class Config.