Simplify name handling

Author: nicolasstucki

library/src/scala/annotation/newMain.scala

@@ -62,45 +62,26 @@ final class newMain extends MainAnnotation[FromString, Any]:
   import newMain._
   import MainAnnotation._
 
-  private inline val argMarker = "--"
-  private inline val shortArgMarker = "-"
-
   private val longArgRegex = "--[a-zA-Z][a-zA-Z0-9]+".r
   private val shortArgRegex = "-[a-zA-Z]".r
 
   extension (param: Parameter)
     private def aliasNames: Seq[String] =
-      param.annotations.collect{ case a: Alias => a.aliases }.flatten
-
-    private def longAliases: Seq[String] =
-      param.aliasNames.filter(_.size > 1).map(longNameWithMarker)
-
-    private def shortAliases: Seq[String] =
-      param.aliasNames.filter(_.size == 1).map(shortNameWithMarker)
-
-  private def isLongName(name: String): Boolean =
-    name.length > 1
-
-  private def isShortName(name: String): Boolean =
-    name.length == 1
+      param.annotations.collect{ case a: Alias => a.aliases.map(getNameWithMarker) }.flatten
 
   private def getNameWithMarker(name: String): String =
-    if isLongName(name) then argMarker + name
-    else if isShortName(name) then shortArgMarker + name
+    if name.length > 1 then s"--$name"
+    else if name.length == 1 then s"-$name"
     else assert(false, "invalid name")
 
-  private def longNameWithMarker(name: String): String = argMarker + name
-  private def shortNameWithMarker(name: String): String = shortArgMarker + name
-
   def command(info: Info, args: Seq[String]): Option[Seq[String]] =
-    val canonicalNames = CanonicalNames(info)
-    canonicalNames.checkNames()
-    if Help.hasHelpArg(canonicalNames, args) then
+    val names = Names(info)
+    if Help.shouldPrintDefaultHelp(names, args) then
       Help.printUsage(info)
       Help.printExplain(info)
       None
     else
-      preProcessArgs(info, canonicalNames, args).orElse {
+      preProcessArgs(info, names, args).orElse {
         Help.printUsage(info)
         None
       }
@@ -122,7 +103,7 @@ final class newMain extends MainAnnotation[FromString, Any]:
   def run(execProgram: () => Any): Unit =
     if !hasParseErrors then execProgram()
 
-  private def preProcessArgs(info: Info, canonicalNames: CanonicalNames, args: Seq[String]): Option[Seq[String]] =
+  private def preProcessArgs(info: Info, names: Names, args: Seq[String]): Option[Seq[String]] =
     var hasError: Boolean = false
     def error(msg: String): Unit = {
       hasError = true
@@ -142,7 +123,7 @@ final class newMain extends MainAnnotation[FromString, Any]:
               case longArgRegex() | shortArgRegex() =>
                 error(s"missing argument for ${name}")
               case value =>
-                canonicalNames.getName(name) match
+                names.canonicalName(name) match
                   case Some(canonicalName) =>
                     byNameArgs += ((canonicalName, value))
                   case None =>
@@ -168,7 +149,7 @@ final class newMain extends MainAnnotation[FromString, Any]:
               byNameArgsMap.get(param.name) match
                 case Some(byNameVarargs) => acc ::: byNameVarargs.toList ::: remainingArgs
                 case None => acc ::: remainingArgs
-            else byNameArgsMap.get(param.name) match
+            else byNameArgsMap.get(getNameWithMarker(param.name)) match
               case Some(argValues) =>
                 assert(argValues.nonEmpty, s"${param.name} present in byNameArgsMap, but it has no argument value")
                 if argValues.length > 1 then
@@ -208,12 +189,12 @@ final class newMain extends MainAnnotation[FromString, Any]:
     /** The name of the special argument to display the method's help.
      *  If one of the method's parameters is called the same, will be ignored.
      */
-    private inline val helpArg = "help"
+    private inline val helpArg = "--help"
 
     /** The short name of the special argument to display the method's help.
      *  If one of the method's parameters uses the same short name, will be ignored.
      */
-    private inline val shortHelpArg = 'h'
+    private inline val shortHelpArg = "-h"
 
     private inline val maxUsageLineLength = 120
 
@@ -222,7 +203,7 @@ final class newMain extends MainAnnotation[FromString, Any]:
         for (param <- info.parameters)
         yield {
           val canonicalName = getNameWithMarker(param.name)
-          val namesPrint = (canonicalName +: param.longAliases ++: param.shortAliases).mkString("[", " | ", "]")
+          val namesPrint = (canonicalName +: param.aliasNames).mkString("[", " | ", "]")
           val shortTypeName = param.typeName.split('.').last
           if param.isVarargs then s"[<$shortTypeName> [<$shortTypeName> [...]]]"
           else if param.hasDefault then s"[$namesPrint <$shortTypeName>]"
@@ -276,7 +257,7 @@ final class newMain extends MainAnnotation[FromString, Any]:
         println("Arguments:")
         for param <- info.parameters do
           val canonicalName = getNameWithMarker(param.name)
-          val otherNames = (param.longAliases ++ param.shortAliases) match {
+          val otherNames = param.aliasNames match {
             case Seq() => ""
             case names => names.mkString("(", ", ", ") ")
           }
@@ -297,59 +278,52 @@ final class newMain extends MainAnnotation[FromString, Any]:
       }
     end printExplain
 
-    def hasHelpArg(canonicalNames: CanonicalNames, args: Seq[String]): Boolean =
-      val helpIsOverridden = canonicalNames.getName(argMarker + helpArg).isDefined
-      val shortHelpIsOverridden = canonicalNames.getShortName(shortArgMarker + shortHelpArg).isDefined
-      (!helpIsOverridden && args.contains(longNameWithMarker(helpArg))) ||
-      (!shortHelpIsOverridden && args.contains(shortNameWithMarker(shortHelpArg.toString)))
+    def shouldPrintDefaultHelp(names: Names, args: Seq[String]): Boolean =
+      val helpIsOverridden = names.canonicalName(helpArg).isDefined
+      val shortHelpIsOverridden = names.canonicalName(shortHelpArg).isDefined
+      (!helpIsOverridden && args.contains(helpArg)) ||
+      (!shortHelpIsOverridden && args.contains(shortHelpArg))
 
   end Help
 
-  private class CanonicalNames(info: Info):
-
-    private val namesToCanonicalName: Map[String, String] = info.parameters.flatMap(
-      param =>
-        val names = param.longAliases.map(_.drop(2))
-        val canonicalName = param.name
-        if isLongName(canonicalName) then (canonicalName +: names).map(_ -> canonicalName)
-        else names.map(_ -> canonicalName)
-    ).toMap
+  private class Names(info: Info):
 
-    private val shortNamesToCanonicalName: Map[String, String] = info.parameters.flatMap(
-      param =>
-        val names = param.shortAliases.map(_.drop(1))
-        val canonicalName = param.name
-        if isShortName(canonicalName) then (canonicalName +: names).map(_ -> canonicalName)
-        else names.map(_ -> canonicalName)
-    ).toMap
+    checkNames()
 
-    def getName(name: String): Option[String] = namesToCanonicalName.get(name.drop(2)).orElse(getShortName(name))
+    private lazy val namesToCanonicalName: Map[String, String] =
+      info.parameters.flatMap(param =>
+        val canonicalName = getNameWithMarker(param.name)
+        (canonicalName -> canonicalName) +: param.aliasNames.map(_ -> canonicalName)
+      ).toMap
 
-    def getShortName(name: String): Option[String] = shortNamesToCanonicalName.get(name.drop(1))
+    def canonicalName(name: String): Option[String] = namesToCanonicalName.get(name)
 
-    override def toString(): String =
-      s"CanonicalNames($namesToCanonicalName, $shortNamesToCanonicalName)"
+    override def toString(): String = s"Names($namesToCanonicalName)"
 
-    def checkNames(): Unit =
+    private def checkNames(): Unit =
       def checkDuplicateNames() =
         val nameAndCanonicalName = info.parameters.flatMap { paramInfo =>
-          (getNameWithMarker(paramInfo.name) +: paramInfo.longAliases ++: paramInfo.shortAliases).map(_ -> paramInfo.name)
+          (getNameWithMarker(paramInfo.name) +: paramInfo.aliasNames).map(_ -> paramInfo.name)
         }
-        val nameToCanonicalNames = nameAndCanonicalName.groupMap(_._1)(_._2)
-        for (name, canonicalNames) <- nameToCanonicalNames if canonicalNames.length > 1 do
+        val nameToNames = nameAndCanonicalName.groupMap(_._1)(_._2)
+        for (name, canonicalNames) <- nameToNames if canonicalNames.length > 1 do
           throw IllegalArgumentException(s"$name is used for multiple parameters: ${canonicalNames.mkString(", ")}")
       def checkValidNames() =
         def isValidArgName(name: String): Boolean =
-          longArgRegex.matches(argMarker + name) || shortArgRegex.matches(shortArgMarker + name)
+          longArgRegex.matches(s"--$name") || shortArgRegex.matches(s"-$name")
         for param <- info.parameters do
           if !isValidArgName(param.name) then
             throw IllegalArgumentException(s"The following argument name is invalid: ${param.name}")
-          for alias <- param.aliasNames if !isValidArgName(alias) do
-            throw IllegalArgumentException(s"The following alias is invalid: $alias")
+          for annot <- param.annotations do
+            annot match
+              case alias: Alias =>
+                for name <- alias.aliases if !isValidArgName(name) do
+                  throw IllegalArgumentException(s"The following alias is invalid: $name")
+              case _ =>
 
       checkValidNames()
       checkDuplicateNames()
-  end CanonicalNames
+  end Names
 
 end newMain