Cleanup

Author: nicolasstucki

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

@@ -265,15 +265,13 @@ object MainProxies {
           val argName = nme.args ++ idx.toString
           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
+          val getterName = if isRepeated then nme.varargGetter else nme.argGetter
           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 argGetter0 = TypeApply(Select(Ident(nme.cmd), getterName), TypeTree(formalType) :: Nil)
           val argGetter =
             if isRepeated then argGetter0
             else Apply(argGetter0, List(Literal(Constant(idx)), defaultValueGetterOpt))
@@ -324,11 +322,11 @@ object MainProxies {
         nme.cmd,
         TypeTree(),
         Apply(
-          Select(instantiateAnnotation(mainAnnot), defn.MainAnnotation_command.name),
+          Select(instantiateAnnotation(mainAnnot), nme.command),
           List(cmdInfo, Ident(nme.args))
         )
       )
-      val run = Apply(Select(Ident(nme.cmd), defn.MainAnnotationCommand_run.name), mainCall)
+      val run = Apply(Select(Ident(nme.cmd), nme.run), mainCall)
       val body = Block(cmdInfo :: cmd :: args, run)
       val mainArg = ValDef(nme.args, TypeTree(defn.ArrayType.appliedTo(defn.StringType)), EmptyTree)
         .withFlags(Param)

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

@@ -852,16 +852,10 @@ class Definitions {
   @tu lazy val XMLTopScopeModule: Symbol = requiredModule("scala.xml.TopScope")
 
   @tu lazy val MainAnnotationClass: ClassSymbol = requiredClass("scala.annotation.MainAnnotation")
-    @tu lazy val MainAnnotation_command: Symbol = MainAnnotationClass.requiredMethod("command")
   @tu lazy val MainAnnotationCommandInfo: ClassSymbol = requiredClass("scala.annotation.MainAnnotation.CommandInfo")
   @tu lazy val MainAnnotationParameterInfo: ClassSymbol = requiredClass("scala.annotation.MainAnnotation.ParameterInfo")
-    @tu lazy val MainAnnotationParameterInfo_withDocumentation: Symbol = MainAnnotationParameterInfo.requiredMethod("withDocumentation")
-    @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_run: Symbol = MainAnnotationCommand.requiredMethod("run")
 
   @tu lazy val CommandLineParserModule: Symbol = requiredModule("scala.util.CommandLineParser")
     @tu lazy val CLP_ParseError: ClassSymbol = CommandLineParserModule.requiredClass("ParseError").typeRef.symbol.asClass

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

@@ -419,6 +419,7 @@ object StdNames {
     val applyOrElse: N          = "applyOrElse"
     val args : N                = "args"
     val argv : N                = "argv"
+    val argGetter : N           = "argGetter"
     val arrayClass: N           = "arrayClass"
     val arrayElementClass: N    = "arrayElementClass"
     val arrayType: N            = "arrayType"
@@ -450,6 +451,7 @@ object StdNames {
     val classType: N            = "classType"
     val clone_ : N              = "clone"
     val cmd: N                  = "cmd"
+    val command: N              = "command"
     val common: N               = "common"
     val compiletime : N         = "compiletime"
     val conforms_ : N           = "$conforms"
@@ -636,6 +638,7 @@ object StdNames {
     val fromOrdinal: N          = "fromOrdinal"
     val values: N               = "values"
     val view_ : N               = "view"
+    val varargGetter : N        = "varargGetter"
     val wait_ : N               = "wait"
     val wildcardType: N         = "wildcardType"
     val withFilter: N           = "withFilter"