Fix order of Child annotations.

Child annotations are stored in reverse order of textual occurrence.
We thus have a stable ordering that we can use for typeclass derivations.

Author: odersky

compiler/src/dotty/tools/dotc/transform/SymUtils.scala

@@ -133,13 +133,13 @@ class SymUtils(val self: Symbol) extends AnyVal {
   def isInaccessibleChildOf(cls: Symbol)(implicit ctx: Context): Boolean =
     self.isLocal && !cls.topLevelClass.isLinkedWith(self.topLevelClass)
 
-  /** If this is a sealed class, its known children */
+  /** If this is a sealed class, its known children in the order of textual occurrence */
   def children(implicit ctx: Context): List[Symbol] = {
     if (self.isType)
       self.setFlag(ChildrenQueried)
     self.annotations.collect {
       case Annotation.Child(child) => child
-    }
+    }.reverse
   }
 
   def hasAnonymousChild(implicit ctx: Context): Boolean =

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -499,12 +499,31 @@ class Namer { typer: Typer =>
     vd.mods.is(JavaEnumValue) // && ownerHasEnumFlag
   }
 
+  /** Add child annotation for `child` to annotations of `cls`. The annotation
+   *  is added at the correct insertion point, so that Child annotations appear
+   *  in reverse order of their start positions.
+   *  @pre `child` must have a position.
+   */
+  final def addChild(cls: Symbol, child: Symbol)(implicit ctx: Context): Unit = {
+    val childStart = child.pos.start
+    def insertInto(annots: List[Annotation]): List[Annotation] =
+      annots.find(_.symbol == defn.ChildAnnot) match {
+        case Some(Annotation.Child(other)) if childStart <= other.pos.start =>
+          assert(childStart != other.pos.start, "duplicate child annotation $child / $other")
+          val (prefix, otherAnnot :: rest) = annots.span(_.symbol != defn.ChildAnnot)
+          prefix ::: otherAnnot :: insertInto(rest)
+        case _ =>
+          Annotation.Child(child) :: annots
+      }
+    cls.annotations = insertInto(cls.annotations)
+  }
+
   /** Add java enum constants */
   def addEnumConstants(mdef: DefTree, sym: Symbol)(implicit ctx: Context): Unit = mdef match {
     case vdef: ValDef if (isEnumConstant(vdef)) =>
       val enumClass = sym.owner.linkedClass
       if (!(enumClass is Flags.Sealed)) enumClass.setFlag(Flags.AbstractSealed)
-      enumClass.addAnnotation(Annotation.Child(sym))
+      addChild(enumClass, sym)
     case _ =>
   }
 
@@ -814,9 +833,9 @@ class Namer { typer: Typer =>
         val cls = parent.classSymbol
         if (cls.is(Sealed)) {
           if ((child.isInaccessibleChildOf(cls) || child.isAnonymousClass) && !sym.hasAnonymousChild)
-            cls.addAnnotation(Annotation.Child(cls))
+            addChild(cls, cls)
           else if (!cls.is(ChildrenQueried))
-            cls.addAnnotation(Annotation.Child(child))
+            addChild(cls, child)
           else
             ctx.error(em"""children of ${cls} were already queried before $sym was discovered.
                           |As a remedy, you could move $sym on the same nesting level as $cls.""",

library/src/scala/annotation/internal/Child.scala

@@ -10,8 +10,13 @@ import scala.annotation.Annotation
  *    case class C() extends A
  *
  *  Then the class symbol `A` would carry the annotations
- *  `@Child[Bref] @Child[Cref]` where `Bref`, `Cref` are TypeRefs
- *  referring to the class symbols of `B` and `C`
+ *  `@Child[Cref]`, @Child[Bref] where `Bref`, `Cref` are TypeRefs
+ *  referring to the class symbols of `B` and `C`.
+ *
+ *  Child annotations always appear in reverse order of textual occurrence.
+ *  I.e. in the example above, it is guaranteed that the child annotation for `C`
+ *  appears before the one for `B`.
+ *
  *  TODO: This should be `Child[T <: AnyKind]`
  */
 class Child[T] extends Annotation