WIP simplify error reporting

Author: nicolasstucki

library/src/scala/annotation/newMain.scala

@@ -79,14 +79,6 @@ final class newMain extends MainAnnotation[FromString, Any]:
 
   private var info: Info = _ // TODO remove this var
 
-  /** A buffer for all errors */
-  private val errors = new mutable.ArrayBuffer[String]
-
-  /** Issue an error, and return an uncallable getter */
-  private def error(msg: String): () => Nothing =
-    errors += msg
-    () => throw new AssertionError("trying to get invalid argument")
-
   private def getAliases(param: Parameter): Seq[String] =
     param.annotations.collect{ case a: Alias => a }.flatMap(_.aliases)
 
@@ -117,6 +109,12 @@ final class newMain extends MainAnnotation[FromString, Any]:
   def command(info: Info, args: Seq[String]): Option[Seq[String]] =
     this.info = info
 
+    val errors = new mutable.ArrayBuffer[String]
+
+    def error(msg: String): Unit = {
+      errors += msg
+    }
+
     val namesToCanonicalName: Map[String, String] = info.parameters.flatMap(
       infos =>
         val names = getAlternativeNames(infos)
@@ -316,24 +314,33 @@ final class newMain extends MainAnnotation[FromString, Any]:
 
   def argGetter[T](param: Parameter, arg: String, defaultArgument: Option[() => T])(using p: FromString[T]): () => T = {
     if arg.nonEmpty then parse[T](param, arg)
-    else defaultArgument match
-      case Some(defaultGetter) => defaultGetter
-      case None => error(s"missing argument for ${param.name}")
+    else
+      assert(param.hasDefault)
+
+      defaultArgument.get
   }
 
   def varargGetter[T](param: Parameter, args: Seq[String])(using p: FromString[T]): () => Seq[T] = {
     val getters = args.map(arg => parse[T](param, arg))
     () => getters.map(_())
   }
 
+  /** A buffer for all parsing errors errors */
+  private lazy val parseErrors = new mutable.ArrayBuffer[String]
+
+  /** Issue an error, and return an uncallable getter */
+  private def parseError(msg: String): () => Nothing =
+    parseErrors += msg
+    () => throw new AssertionError("trying to get invalid argument")
+
   private def parse[T](param: Parameter, arg: String)(using p: FromString[T]): () => T =
     p.fromStringOption(arg) match
       case Some(t) => () => t
-      case None => error(s"could not parse argument for `${param.name}` of type ${param.typeName.split('.').last}: $arg")
+      case None => parseError(s"could not parse argument for `${param.name}` of type ${param.typeName.split('.').last}: $arg")
 
   def run(execProgram: () => Any): Unit = {
-    if errors.nonEmpty then
-      for msg <- errors do println(s"Error: $msg")
+    if parseErrors.nonEmpty then
+      for msg <- parseErrors do println(s"Error: $msg")
       usage()
     else
       execProgram()