Swap order of elements in Annotated

Now it's annotated first, annotation second.

This is in line with AnnotatedType and in line with the principle
that tree arguments should come in the order they are written. The
reason why the order was swapped before is historical - Scala2 did it
that way.

Author: odersky

src/dotty/tools/dotc/ast/Desugar.scala

@@ -632,7 +632,7 @@ object desugar {
     val selector = makeTuple(params.map(p => Ident(p.name)))
 
     if (unchecked)
-      Function(params, Match(Annotated(New(ref(defn.UncheckedAnnotType)), selector), cases))
+      Function(params, Match(Annotated(selector, New(ref(defn.UncheckedAnnotType))), cases))
     else
       Function(params, Match(selector, cases))
   }
@@ -661,7 +661,7 @@ object desugar {
    *      tree @cls
    */
   def makeAnnotated(cls: Symbol, tree: Tree)(implicit ctx: Context) =
-    Annotated(untpd.New(untpd.TypeTree(cls.typeRef), Nil), tree)
+    Annotated(tree, untpd.New(untpd.TypeTree(cls.typeRef), Nil))
 
   private def derivedValDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(implicit ctx: Context) = {
     val vdef = ValDef(named.name.asTermName, tpt, rhs)
@@ -904,8 +904,8 @@ object desugar {
         if ((ctx.mode is Mode.Type) && op == nme.raw.STAR) {
           val seqType = if (ctx.compilationUnit.isJava) defn.ArrayType else defn.SeqType
           Annotated(
-            New(ref(defn.RepeatedAnnotType), Nil :: Nil),
-            AppliedTypeTree(ref(seqType), t))
+            AppliedTypeTree(ref(seqType), t),
+            New(ref(defn.RepeatedAnnotType), Nil :: Nil))
         } else {
           assert(ctx.mode.isExpr || ctx.reporter.hasErrors, ctx.mode)
           Select(t, op)
@@ -1052,7 +1052,7 @@ object desugar {
       case Alternative(trees) =>
         for (tree <- trees; (vble, _) <- getVariables(tree))
           ctx.error("illegal variable in pattern alternative", vble.pos)
-      case Annotated(annot, arg) =>
+      case Annotated(arg, _) =>
         collect(arg)
       case InterpolatedString(_, _, elems) =>
         elems foreach collect

src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -183,7 +183,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case RefinedTypeTree(tpt, refinements) => mayBeTypePat(tpt) || refinements.exists(_.isInstanceOf[Bind])
     case AppliedTypeTree(tpt, args) => mayBeTypePat(tpt) || args.exists(_.isInstanceOf[Bind])
     case SelectFromTypeTree(tpt, _) => mayBeTypePat(tpt)
-    case Annotated(_, tpt) => mayBeTypePat(tpt)
+    case Annotated(tpt, _) => mayBeTypePat(tpt)
     case _ => false
   }
 

src/dotty/tools/dotc/ast/Trees.scala

@@ -709,7 +709,7 @@ object Trees {
   }
 
   /** arg @annot */
-  case class Annotated[-T >: Untyped] private[ast] (annot: Tree[T], arg: Tree[T])
+  case class Annotated[-T >: Untyped] private[ast] (arg: Tree[T], annot: Tree[T])
     extends ProxyTree[T] {
     type ThisTree[-T >: Untyped] = Annotated[T]
     def forwardTo = arg
@@ -1082,9 +1082,9 @@ object Trees {
         case tree: PackageDef if (pid eq tree.pid) && (stats eq tree.stats) => tree
         case _ => finalize(tree, untpd.PackageDef(pid, stats))
       }
-      def Annotated(tree: Tree)(annot: Tree, arg: Tree)(implicit ctx: Context): Annotated = tree match {
-        case tree: Annotated if (annot eq tree.annot) && (arg eq tree.arg) => tree
-        case _ => finalize(tree, untpd.Annotated(annot, arg))
+      def Annotated(tree: Tree)(arg: Tree, annot: Tree)(implicit ctx: Context): Annotated = tree match {
+        case tree: Annotated if (arg eq tree.arg) && (annot eq tree.annot) => tree
+        case _ => finalize(tree, untpd.Annotated(arg, annot))
       }
       def Thicket(tree: Tree)(trees: List[Tree]): Thicket = tree match {
         case tree: Thicket if trees eq tree.trees => tree
@@ -1198,8 +1198,8 @@ object Trees {
           cpy.Import(tree)(transform(expr), selectors)
         case PackageDef(pid, stats) =>
           cpy.PackageDef(tree)(transformSub(pid), transformStats(stats))
-        case Annotated(annot, arg) =>
-          cpy.Annotated(tree)(transform(annot), transform(arg))
+        case Annotated(arg, annot) =>
+          cpy.Annotated(tree)(transform(arg), transform(annot))
         case Thicket(trees) =>
           val trees1 = transform(trees)
           if (trees1 eq trees) tree else Thicket(trees1)
@@ -1304,8 +1304,8 @@ object Trees {
             this(x, expr)
           case PackageDef(pid, stats) =>
             this(this(x, pid), stats)(localCtx)
-          case Annotated(annot, arg) =>
-            this(this(x, annot), arg)
+          case Annotated(arg, annot) =>
+            this(this(x, arg), annot)
           case Thicket(ts) =>
             this(x, ts)
         }

src/dotty/tools/dotc/ast/tpd.scala

@@ -292,8 +292,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def PackageDef(pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef =
     ta.assignType(untpd.PackageDef(pid, stats), pid)
 
-  def Annotated(annot: Tree, arg: Tree)(implicit ctx: Context): Annotated =
-    ta.assignType(untpd.Annotated(annot, arg), annot, arg)
+  def Annotated(arg: Tree, annot: Tree)(implicit ctx: Context): Annotated =
+    ta.assignType(untpd.Annotated(arg, annot), arg, annot)
 
   def Throw(expr: Tree)(implicit ctx: Context): Tree =
     ref(defn.throwMethod).appliedTo(expr)
@@ -568,11 +568,11 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
     }
 
-    override def Annotated(tree: Tree)(annot: Tree, arg: Tree)(implicit ctx: Context): Annotated = {
-      val tree1 = untpd.cpy.Annotated(tree)(annot, arg)
+    override def Annotated(tree: Tree)(arg: Tree, annot: Tree)(implicit ctx: Context): Annotated = {
+      val tree1 = untpd.cpy.Annotated(tree)(arg, annot)
       tree match {
         case tree: Annotated if (arg.tpe eq tree.arg.tpe) && (annot eq tree.annot) => tree1.withTypeUnchecked(tree.tpe)
-        case _ => ta.assignType(tree1, annot, arg)
+        case _ => ta.assignType(tree1, arg, annot)
       }
     }
 

src/dotty/tools/dotc/ast/untpd.scala

@@ -159,7 +159,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Template(constr: DefDef, parents: List[Tree], self: ValDef, body: LazyTreeList): Template = new Template(constr, parents, self, body)
   def Import(expr: Tree, selectors: List[untpd.Tree]): Import = new Import(expr, selectors)
   def PackageDef(pid: RefTree, stats: List[Tree]): PackageDef = new PackageDef(pid, stats)
-  def Annotated(annot: Tree, arg: Tree): Annotated = new Annotated(annot, arg)
+  def Annotated(arg: Tree, annot: Tree): Annotated = new Annotated(arg, annot)
 
   // ------ Additional creation methods for untyped only -----------------
 

src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -1186,7 +1186,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       case ANNOTATEDtree =>
         val annot = readTreeRef()
         val arg = readTreeRef()
-        Annotated(annot, arg)
+        Annotated(arg, annot)
 
       case SINGLETONTYPEtree =>
         SingletonTypeTree(readTreeRef())

src/dotty/tools/dotc/parsing/Parsers.scala

@@ -338,7 +338,7 @@ object Parsers {
     def isWildcard(t: Tree): Boolean = t match {
       case Ident(name1) => placeholderParams.nonEmpty && name1 == placeholderParams.head.name
       case Typed(t1, _) => isWildcard(t1)
-      case t: Annotated => isWildcard(t.arg)
+      case Annotated(t1, _) => isWildcard(t1)
       case Parens(t1) => isWildcard(t1)
       case _ => false
     }
@@ -742,7 +742,7 @@ object Parsers {
     def annotType(): Tree = annotTypeRest(simpleType())
 
     def annotTypeRest(t: Tree): Tree =
-      if (in.token == AT) annotTypeRest(atPos(t.pos.start) { Annotated(annot(), t) })
+      if (in.token == AT) annotTypeRest(atPos(t.pos.start) { Annotated(t, annot()) })
       else t
 
     /** SimpleType       ::=  SimpleType TypeArgs
@@ -900,7 +900,7 @@ object Parsers {
     private final def findWildcardType(t: Tree): Option[Position] = t match {
       case TypeBoundsTree(_, _) => Some(t.pos)
       case Parens(t1) => findWildcardType(t1)
-      case Annotated(_, t1) => findWildcardType(t1)
+      case Annotated(t1, _) => findWildcardType(t1)
       case _ => None
     }
 
@@ -1071,7 +1071,7 @@ object Parsers {
             syntaxErrorOrIncomplete("`*' expected"); t
           }
         case AT if location != Location.InPattern =>
-          (t /: annotations()) ((t, annot) => Annotated(annot, t))
+          (t /: annotations())(Annotated)
         case _ =>
           val tpt = typeDependingOn(location)
           if (isWildcard(t) && location != Location.InPattern) {

src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -434,7 +434,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         "package " ~ toTextPackageId(pid) ~ bodyText
       case tree: Template =>
         toTextTemplate(tree)
-      case Annotated(annot, arg) =>
+      case Annotated(arg, annot) =>
         toTextLocal(arg) ~~ annotText(annot)
       case EmptyTree =>
         "<empty>"

src/dotty/tools/dotc/transform/ExpandSAMs.scala

@@ -74,7 +74,7 @@ class ExpandSAMs extends MiniPhaseTransform { thisTransformer =>
             Bind(defaultSym, Underscore(selector.tpe.widen)),
             EmptyTree,
             Literal(Constant(false)))
-        val annotated = Annotated(New(ref(defn.UncheckedAnnotType)), paramRef)
+        val annotated = Annotated(paramRef, New(ref(defn.UncheckedAnnotType)))
         cpy.Match(applyRhs)(annotated, cases.map(translateCase) :+ defaultCase)
       case _ =>
         tru

src/dotty/tools/dotc/transform/PostTyper.scala

@@ -262,8 +262,8 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
         case tree: New if !inJavaAnnot && !parentNews.contains(tree) =>
           Checking.checkInstantiable(tree.tpe, tree.pos)
           super.transform(tree)
-        case tree @ Annotated(annot, annotated) =>
-          cpy.Annotated(tree)(transformAnnot(annot), transform(annotated))
+        case tree @ Annotated(annotated, annot) =>
+          cpy.Annotated(tree)(transform(annotated), transformAnnot(annot))
         case tree: TypeTree =>
           tree.withType(
             tree.tpe match {

src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -252,7 +252,7 @@ class TreeChecker extends Phase with SymTransformer {
       // case tree: TypeBoundsTree =>
       // case tree: Alternative =>
       // case tree: PackageDef =>
-      case Annotated(_, arg) =>
+      case Annotated(arg, _) =>
         assertIdentNotJavaClass(arg)
       case _ =>
     }

src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -500,7 +500,7 @@ trait TypeAssigner {
   def assignType(tree: untpd.Import, sym: Symbol)(implicit ctx: Context) =
     tree.withType(sym.nonMemberTermRef)
 
-  def assignType(tree: untpd.Annotated, annot: Tree, arg: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.Annotated, arg: Tree, annot: Tree)(implicit ctx: Context) =
     tree.withType(AnnotatedType(arg.tpe.widen, Annotation(annot)))
 
   def assignType(tree: untpd.PackageDef, pid: Tree)(implicit ctx: Context) =

src/dotty/tools/dotc/typer/Typer.scala

@@ -1342,7 +1342,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val annot1 = typedExpr(tree.annot, defn.AnnotationType)
     val arg1 = typed(tree.arg, pt)
     if (ctx.mode is Mode.Type)
-      assignType(cpy.Annotated(tree)(annot1, arg1), annot1, arg1)
+      assignType(cpy.Annotated(tree)(arg1, annot1), arg1, annot1)
     else {
       val tpt = TypeTree(AnnotatedType(arg1.tpe.widen, Annotation(annot1)))
       assignType(cpy.Typed(tree)(arg1, tpt), tpt)