Rename ParameterInfos to ParameterInfo

Author: nicolasstucki

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

@@ -152,10 +152,10 @@ object MainProxies {
    *           args,
    *           "f",
    *           "Lorem ipsum dolor sit amet consectetur adipiscing elit.",
-   *           new scala.annotation.MainAnnotation.ParameterInfos("x", "S")
+   *           new scala.annotation.MainAnnotation.ParameterInfo("x", "S")
    *             .withDocumentation("my param x")
    *             .withAnnotations(new scala.main.Alias("myX")),
-   *           new scala.annotation.MainAnnotation.ParameterInfos("ys", "T")
+   *           new scala.annotation.MainAnnotation.ParameterInfo("ys", "T")
    *             .withDocumentation("all my params y")
    *         )
    *
@@ -170,8 +170,8 @@ object MainProxies {
     import tpd._
 
     /**
-      * Computes the symbols of the default values of the function. Since they cannot be infered anymore at this
-      * point of the compilation, they must be explicitely passed by [[mainProxy]].
+      * Computes the symbols of the default values of the function. Since they cannot be inferred anymore at this
+      * point of the compilation, they must be explicitly passed by [[mainProxy]].
       */
     def defaultValueSymbols(scope: Tree, funSymbol: Symbol): DefaultValueSymbols =
       scope match {
@@ -239,7 +239,7 @@ object MainProxies {
       *   `val args0: () => S = cmd.argGetter[S]("x", None)`
       * part of the code.
       * For each tuple, the first element is a ref to `args0`, the second is the whole definition, the third
-      * is the ParameterInfos definition associated to this argument.
+      * is the ParameterInfo definition associated to this argument.
       */
     def createArgs(mt: MethodType, cmdName: TermName): List[(Tree, ValDef, Tree)] =
       mt.paramInfos.zip(mt.paramNames).zipWithIndex.map {
@@ -254,29 +254,29 @@ object MainProxies {
             else (argRef0, formal, defn.MainAnnotationCommand_argGetter)
           }
 
-          // The ParameterInfos
+          // The ParameterInfo
           val parameterInfos = {
             val param = paramName.toString
             val paramInfosTree = New(
-              TypeTree(defn.MainAnnotationParameterInfos.typeRef),
-              // Arguments to be passed to ParameterInfos' constructor
+              TypeTree(defn.MainAnnotationParameterInfo.typeRef),
+              // Arguments to be passed to ParameterInfo' constructor
               List(List(lit(param), lit(formalType.show)))
             )
 
             /*
-             * Assignations to be made after the creation of the ParameterInfos.
+             * Assignations to be made after the creation of the ParameterInfo.
              * For example:
              *   args0paramInfos.withDocumentation("my param x")
              * is represented by the pair
-             *   defn.MainAnnotationParameterInfos_withDocumentation -> List(lit("my param x"))
+             *   defn.MainAnnotationParameterInfo_withDocumentation -> List(lit("my param x"))
              */
             var assignations: List[(Symbol, List[Tree])] = Nil
             for (doc <- documentation.argDocs.get(param))
-              assignations = (defn.MainAnnotationParameterInfos_withDocumentation -> List(lit(doc))) :: assignations
+              assignations = (defn.MainAnnotationParameterInfo_withDocumentation -> List(lit(doc))) :: assignations
 
             val instanciatedAnnots = paramAnnotations(n).map(instanciateAnnotation).toList
             if instanciatedAnnots.nonEmpty then
-              assignations = (defn.MainAnnotationParameterInfos_withAnnotations -> instanciatedAnnots) :: assignations
+              assignations = (defn.MainAnnotationParameterInfo_withAnnotations -> instanciatedAnnots) :: assignations
 
             assignations.foldLeft[Tree](paramInfosTree){ case (tree, (setterSym, values)) => Apply(Select(tree, setterSym.name), values) }
           }

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

@@ -851,9 +851,9 @@ class Definitions {
 
   @tu lazy val MainAnnotationClass: ClassSymbol = requiredClass("scala.annotation.MainAnnotation")
     @tu lazy val MainAnnotation_command: Symbol = MainAnnotationClass.requiredMethod("command")
-  @tu lazy val MainAnnotationParameterInfos: ClassSymbol = requiredClass("scala.annotation.MainAnnotation.ParameterInfos")
-    @tu lazy val MainAnnotationParameterInfos_withDocumentation: Symbol = MainAnnotationParameterInfos.requiredMethod("withDocumentation")
-    @tu lazy val MainAnnotationParameterInfos_withAnnotations: Symbol = MainAnnotationParameterInfos.requiredMethod("withAnnotations")
+  @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")

library/src/scala/annotation/MainAnnotation.scala

@@ -12,6 +12,7 @@ package scala.annotation
  */
 @experimental
 trait MainAnnotation extends StaticAnnotation:
+  import MainAnnotation.*
 
   /** The class used for argument string parsing. E.g. `scala.util.CommandLineParser.FromString`,
    *  but could be something else
@@ -22,13 +23,13 @@ trait MainAnnotation extends StaticAnnotation:
   type MainResultType
 
   /** A new command with arguments from `args` */
-  def command(args: Array[String], commandName: String, documentation: String, parameterInfoss: MainAnnotation.ParameterInfos*): MainAnnotation.Command[ArgumentParser, MainResultType]
+  def command(args: Array[String], commandName: String, documentation: String, parameterInfos: ParameterInfo*): Command[ArgumentParser, MainResultType]
 end MainAnnotation
 
 @experimental
 object MainAnnotation:
 
-  final class ParameterInfos private (
+  final class ParameterInfo private (
     /** The name of the parameter */
     val name: String,
     /** The name of the parameter's type */
@@ -38,17 +39,17 @@ object MainAnnotation:
     /** The ParameterAnnotations associated with the parameter. Defaults to Seq.empty. */
     val annotations: Seq[ParameterAnnotation],
   ) {
-    /** ParameterInfos with a name and the type of the parameter */
+    /** ParameterInfo with a name and the type of the parameter */
     def this(name: String, typeName: String) =
       this(name, typeName, None, Seq.empty)
 
-    /** Copy this ParameterInfos and sets the documentation */
-    def withDocumentation(doc: String): ParameterInfos =
-      new ParameterInfos(name, typeName, Some(doc), annotations)
+    /** Copy this ParameterInfo and sets the documentation */
+    def withDocumentation(doc: String): ParameterInfo =
+      new ParameterInfo(name, typeName, Some(doc), annotations)
 
-    /** Copy this ParameterInfos and sets the annotations */
-    def withAnnotations(annots: ParameterAnnotation*): ParameterInfos =
-      new ParameterInfos(name, typeName, documentation, annots)
+    /** Copy this ParameterInfo and sets the annotations */
+    def withAnnotations(annots: ParameterAnnotation*): ParameterInfo =
+      new ParameterInfo(name, typeName, documentation, annots)
 
     override def toString: String = s"$name: $typeName"
   }
@@ -68,6 +69,6 @@ object MainAnnotation:
     def run(program: => MainResultType): Unit
   end Command
 
-  /** Marker trait for annotations that will be included in the ParameterInfos annotations. */
+  /** Marker trait for annotations that will be included in the ParameterInfo annotations. */
   trait ParameterAnnotation extends StaticAnnotation
 end MainAnnotation

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

@@ -22,13 +22,13 @@ end Test
 
 @experimental
 class mainAwait(timeout: Int = 2) extends MainAnnotation:
-  import MainAnnotation._
+  import MainAnnotation.*
 
   override type ArgumentParser[T] = util.CommandLineParser.FromString[T]
   override type MainResultType = Future[Any]
 
   // This is a toy example, it only works with positional args
-  override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: MainAnnotation.ParameterInfos*) =
+  override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: ParameterInfo*) =
     new Command[ArgumentParser, MainResultType]:
       private var idx = 0
 

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

@@ -29,12 +29,12 @@ end Test
 // This is a toy example, it only works with positional args
 @experimental
 class myMain(runs: Int = 3)(after: String*) extends MainAnnotation:
-  import MainAnnotation._
+  import MainAnnotation.*
 
   override type ArgumentParser[T] = util.CommandLineParser.FromString[T]
   override type MainResultType = Any
 
-  override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: MainAnnotation.ParameterInfos*) =
+  override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: ParameterInfo*) =
     new Command[ArgumentParser, MainResultType]:
       private var idx = 0
 

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

@@ -11,11 +11,13 @@ end Test
 
 @experimental
 class mainNoArgs extends MainAnnotation:
+  import MainAnnotation.*
+
   override type ArgumentParser[T] = util.CommandLineParser.FromString[T]
   override type MainResultType = Any
 
-  override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: MainAnnotation.ParameterInfos*) =
-    new MainAnnotation.Command[ArgumentParser, MainResultType]:
+  override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: ParameterInfo*) =
+    new Command[ArgumentParser, MainResultType]:
       override def argGetter[T](name: String, optDefaultValueGetter: Option[() => T])(using p: ArgumentParser[T]): () => T = ???
 
       override def varargGetter[T](name: String)(using p: ArgumentParser[T]): () => Seq[T] = ???

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

@@ -11,11 +11,13 @@ end Test
 
 @experimental
 class mainManyArgs(i1: Int, s2: String, i3: Int) extends MainAnnotation:
+  import MainAnnotation.*
+
   override type ArgumentParser[T] = util.CommandLineParser.FromString[T]
   override type MainResultType = Any
 
-  override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: MainAnnotation.ParameterInfos*) =
-    new MainAnnotation.Command[ArgumentParser, MainResultType]:
+  override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: ParameterInfo*) =
+    new Command[ArgumentParser, MainResultType]:
       override def argGetter[T](name: String, optDefaultGetter: Option[() => T])(using p: ArgumentParser[T]): () => T = ???
 
       override def varargGetter[T](name: String)(using p: ArgumentParser[T]): () => Seq[T] = ???

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

@@ -13,11 +13,13 @@ end Test
 
 @experimental
 class mainManyArgs(o: Option[Int]) extends MainAnnotation:
+  import MainAnnotation.*
+
   override type ArgumentParser[T] = util.CommandLineParser.FromString[T]
   override type MainResultType = Any
 
-  override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: MainAnnotation.ParameterInfos*) =
-    new MainAnnotation.Command[ArgumentParser, MainResultType]:
+  override def command(args: Array[String], commandName: String, docComment: String, parameterInfos: ParameterInfo*) =
+    new Command[ArgumentParser, MainResultType]:
       override def argGetter[T](name: String, optDefaultValueGetter: Option[() => T])(using p: ArgumentParser[T]): () => T = ???
 
       override def varargGetter[T](name: String)(using p: ArgumentParser[T]): () => Seq[T] = ???