Simplify Command API

Replace `argGetter`/`varargsGetter` with `parseArg`/`parseVararg`.
This new version returns an `Option[T]` instead of a `() => T`.
`None` can be used to state that this argument could not be parsed and
continue with the next `parseArg`.

The expectation is that `run` will first check if there was a parsing
failure and then call the main methods (just as we do with the lambdas).

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/MainProxies.scala

@@ -159,10 +159,10 @@ object MainProxies {
    *             .withDocumentation("all my params y")
    *         )
    *
-   *         val args0: () => S = cmd.argGetter[S](0, None)
-   *         val args1: () => Seq[T] = cmd.varargGetter[T]
+   *         val args0: Option[S] = cmd.parseArg[S](0, None)
+   *         val args1: Option[Seq[T]] = cmd.parseVararg[T]
    *
-   *         cmd.run(f(args0(), args1()*))
+   *         cmd.run(f(args0.get, args1.get*))
    *       }
    *     }
    */
@@ -258,7 +258,7 @@ object MainProxies {
     /**
       * Creates a list of references and definitions of arguments.
       * The goal is to create the
-      *   `val args0: () => S = cmd.argGetter[S](0, None)`
+      *   `val args0: Option[S] = cmd.parseArg[S](0, None)`
       * part of the code.
       */
     def argValDefs(mt: MethodType): List[ValDef] =
@@ -267,28 +267,28 @@ object MainProxies {
           val isRepeated = formal.isRepeatedParam
           val formalType = if isRepeated then formal.argTypes.head else formal
           val getterSym =
-            if isRepeated then defn.MainAnnotationCommand_varargGetter
-            else defn.MainAnnotationCommand_argGetter
+            if isRepeated then defn.MainAnnotationCommand_parseVararg
+            else defn.MainAnnotationCommand_parseArg
           val defaultValueGetterOpt = defaultValueSymbols.get(idx) match
             case None => ref(defn.NoneModule.termRef)
             case Some(dvSym) =>
                val value = unitToValue(ref(dvSym.termRef))
                Apply(ref(defn.SomeClass.companionModule.termRef), value)
-          val argGetter0 = TypeApply(Select(Ident(nme.cmd), getterSym.name), TypeTree(formalType) :: Nil)
-          val argGetter =
-            if isRepeated then argGetter0
-            else Apply(argGetter0, List(Literal(Constant(idx)), defaultValueGetterOpt))
+          val parseArg0 = TypeApply(Select(Ident(nme.cmd), getterSym.name), TypeTree(formalType) :: Nil)
+          val parseArg =
+            if isRepeated then parseArg0
+            else Apply(parseArg0, List(Literal(Constant(idx)), defaultValueGetterOpt))
 
-          ValDef(argName, TypeTree(), argGetter)
+          ValDef(argName, TypeTree(), parseArg)
     end argValDefs
 
 
     /** Create a list of argument references that will be passed as argument to the main method.
-     *  `args0`, ...`argn*`
+     *  `args0.get`, ...`argn.get*`
      */
     def argRefs(mt: MethodType): List[Tree] =
       for ((formal, paramName), idx) <- mt.paramInfos.zip(mt.paramNames).zipWithIndex yield
-        val argRef = Apply(Ident(nme.args ++ idx.toString), Nil)
+        val argRef = Select(Ident(nme.args ++ idx.toString), nme.get)
         if formal.isRepeatedParam then repeated(argRef) else argRef
     end argRefs
 

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -856,8 +856,8 @@ class Definitions {
     @tu lazy val MainAnnotationParameterInfo_withAnnotations: Symbol = MainAnnotationParameterInfo.requiredMethod("withAnnotations")
   @tu lazy val MainAnnotationParameterAnnotation: ClassSymbol = requiredClass("scala.annotation.MainAnnotation.ParameterAnnotation")
   @tu lazy val MainAnnotationCommand: ClassSymbol = requiredClass("scala.annotation.MainAnnotation.Command")
-    @tu lazy val MainAnnotationCommand_argGetter: Symbol = MainAnnotationCommand.requiredMethod("argGetter")
-    @tu lazy val MainAnnotationCommand_varargGetter: Symbol = MainAnnotationCommand.requiredMethod("varargGetter")
+    @tu lazy val MainAnnotationCommand_parseArg: Symbol = MainAnnotationCommand.requiredMethod("parseArg")
+    @tu lazy val MainAnnotationCommand_parseVararg: Symbol = MainAnnotationCommand.requiredMethod("parseVararg")
     @tu lazy val MainAnnotationCommand_run: Symbol = MainAnnotationCommand.requiredMethod("run")
 
   @tu lazy val CommandLineParserModule: Symbol = requiredModule("scala.util.CommandLineParser")

library/src/scala/annotation/MainAnnotation.scala

@@ -6,7 +6,7 @@ package scala.annotation
  *  The protocol of calls from compiler-main is as follows:
  *
  *    - create a `command` with the command line arguments,
- *    - for each parameter of user-main, a call to `command.argGetter`,
+ *    - for each parameter of user-main, a call to `command.parseArg`,
  *      or `command.argsGetter` if is a final varargs parameter,
  *    - a call to `command.run` with the closure of user-main applied to all arguments.
  */
@@ -72,10 +72,10 @@ object MainAnnotation:
   trait Command[Parser[_], Result]:
 
     /** The getter for the `idx`th argument of type `T` */
-    def argGetter[T](idx: Int, defaultArgument: Option[() => T])(using Parser[T]): () => T
+    def parseArg[T](idx: Int, defaultArgument: Option[() => T])(using Parser[T]): Option[T]
 
     /** The getter for a final varargs argument of type `T*` */
-    def varargGetter[T](using Parser[T]): () => Seq[T]
+    def parseVararg[T](using Parser[T]): Option[Seq[T]]
 
     /** Run `program` if all arguments are valid,
      *  or print usage information and/or error messages.

tests/run/main-annotation-homemade-annot-1.scala

@@ -37,11 +37,11 @@ class mainAwait(timeout: Int = 2) extends MainAnnotation:
   // This is a toy example, it only works with positional args
   override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: ParameterInfo*) =
     new Command[Parser, Result]:
-      override def argGetter[T](idx: Int, defaultArgument: Option[() => T])(using p: Parser[T]): () => T =
-        () => p.fromString(args(idx))
+      override def parseArg[T](idx: Int, defaultArgument: Option[() => T])(using p: Parser[T]): Option[T] =
+        Some(p.fromString(args(idx)))
 
-      override def varargGetter[T](using p: Parser[T]): () => Seq[T] =
-        () => for i <- ((parameterInfos.length-1) until args.length) yield p.fromString(args(i))
+      override def parseVararg[T](using p: Parser[T]): Option[Seq[T]] =
+        Some(for i <- ((parameterInfos.length-1) until args.length) yield p.fromString(args(i)))
 
       override def run(f: => Result): Unit = println(Await.result(f, Duration(timeout, SECONDS)))
 end mainAwait

tests/run/main-annotation-homemade-annot-2.scala

@@ -37,11 +37,11 @@ class myMain(runs: Int = 3)(after: String*) extends MainAnnotation:
   override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: ParameterInfo*) =
     new Command[Parser, Result]:
 
-      override def argGetter[T](idx: Int, defaultArgument: Option[() => T])(using p: Parser[T]): () => T =
-        () => p.fromString(args(idx))
+      override def parseArg[T](idx: Int, defaultArgument: Option[() => T])(using p: Parser[T]): Option[T] =
+        Some(p.fromString(args(idx)))
 
-      override def varargGetter[T](using p: Parser[T]): () => Seq[T] =
-        () => for i <- (parameterInfos.length until args.length) yield p.fromString(args(i))
+      override def parseVararg[T](using p: Parser[T]): Option[Seq[T]] =
+        Some(for i <- (parameterInfos.length until args.length) yield p.fromString(args(i)))
 
       override def run(f: => Result): Unit =
         for (_ <- 1 to runs)

tests/run/main-annotation-homemade-annot-3.scala

@@ -18,9 +18,9 @@ class mainNoArgs extends MainAnnotation:
 
   override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: ParameterInfo*) =
     new Command[Parser, Result]:
-      override def argGetter[T](idx: Int, defaultArgument: Option[() => T])(using p: Parser[T]): () => T = ???
+      override def parseArg[T](idx: Int, defaultArgument: Option[() => T])(using p: Parser[T]): Option[T] = None
 
-      override def varargGetter[T](using p: Parser[T]): () => Seq[T] = ???
+      override def parseVararg[T](using p: Parser[T]): Option[Seq[T]] = None
 
       override def run(f: => Result): Unit = f
   end command

tests/run/main-annotation-homemade-annot-4.scala

@@ -18,9 +18,9 @@ class mainManyArgs(i1: Int, s2: String, i3: Int) extends MainAnnotation:
 
   override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: ParameterInfo*) =
     new Command[Parser, Result]:
-      override def argGetter[T](idx: Int, optDefaultGetter: Option[() => T])(using p: Parser[T]): () => T = ???
+      override def parseArg[T](idx: Int, optDefaultGetter: Option[() => T])(using p: Parser[T]): Option[T] = None
 
-      override def varargGetter[T](using p: Parser[T]): () => Seq[T] = ???
+      override def parseVararg[T](using p: Parser[T]): Option[Seq[T]] = None
 
       override def run(f: => Result): Unit = f
   end command

tests/run/main-annotation-homemade-annot-5.scala

@@ -20,9 +20,9 @@ class mainManyArgs(o: Option[Int]) extends MainAnnotation:
 
   override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: ParameterInfo*) =
     new Command[Parser, Result]:
-      override def argGetter[T](idx: Int, defaultArgument: Option[() => T])(using p: Parser[T]): () => T = ???
+      override def parseArg[T](idx: Int, defaultArgument: Option[() => T])(using p: Parser[T]): Option[T] = None
 
-      override def varargGetter[T](using p: Parser[T]): () => Seq[T] = ???
+      override def parseVararg[T](using p: Parser[T]): Option[Seq[T]] = None
 
       override def run(f: => Result): Unit = f
   end command

tests/run/main-annotation-homemade-annot-6.check

@@ -7,8 +7,8 @@ command(
     ParameterInfo(name="j", typeName="java.lang.String", hasDefault=true, isVarargs=false, documentation="", annotations=List())
   )*
 )
-argGetter(0, None)
-argGetter(1, Some(2))
+parseArg(0, None)
+parseArg(1, Some(2))
 run()
 foo(42, abc)
 
@@ -21,8 +21,8 @@ command(
     ParameterInfo(name="rest", typeName="scala.Int", hasDefault=false, isVarargs=true, documentation="", annotations=List())
   )*
 )
-argGetter(0, None)
-varargGetter()
+parseArg(0, None)
+parseVararg()
 run()
 bar(List(42), 42, 42)
 

tests/run/main-annotation-homemade-annot-6.scala

@@ -35,13 +35,13 @@ class myMain extends MainAnnotation:
          |  ${parameterInfos.map(paramInfoString).mkString("Seq(\n", ",\n", "\n  )*")}
          |)""".stripMargin)
     new Command[Parser, Result]:
-      override def argGetter[T](idx: Int, defaultArgument: Option[() => T])(using p: Parser[T]): () => T =
-        println(s"argGetter($idx, ${defaultArgument.map(_())})")
-        () => p.make
+      override def parseArg[T](idx: Int, defaultArgument: Option[() => T])(using p: Parser[T]): Option[T] =
+        println(s"parseArg($idx, ${defaultArgument.map(_())})")
+        Some(p.make)
 
-      override def varargGetter[T](using p: Parser[T]): () => Seq[T] =
-        println("varargGetter()")
-        () => Seq(p.make, p.make)
+      override def parseVararg[T](using p: Parser[T]): Option[Seq[T]] =
+        println("parseVararg()")
+        Some(Seq(p.make, p.make))
 
       override def run(f: => Result): Unit =
         println("run()")