Reorganize children handling

 - set Child annotations during completion instead of in PostTyper
 - report an error if children are added after a `children` query.

The purpose of these changes is to make it possible to query children
safely during typer.

Author: odersky

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

@@ -103,7 +103,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
 
     private def processMemberDef(tree: Tree)(implicit ctx: Context): tree.type = {
       val sym = tree.symbol
-      sym.registerIfChild()
       sym.transformAnnotations(transformAnnot)
       sym.defTree = tree
       tree

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

@@ -122,27 +122,6 @@ class SymUtils(val self: Symbol) extends AnyVal {
     self
   }
 
-  /** If this symbol is an enum value or a named class, register it as a child
-   *  in all direct parent classes which are sealed.
-   */
-  def registerIfChild()(implicit ctx: Context): Unit = {
-    def register(child: Symbol, parent: Type) = {
-      val cls = parent.classSymbol
-      if (cls.is(Sealed)) {
-        if ((child.isInaccessibleChildOf(cls) || child.isAnonymousClass) && !self.hasAnonymousChild)
-          cls.addAnnotation(Annotation.Child(cls))
-        else cls.addAnnotation(Annotation.Child(child))
-      }
-    }
-    if (self.isClass && !self.isEnumAnonymClass)
-      self.asClass.classParents.foreach { parent =>
-        val child = if (self.is(Module)) self.sourceModule else self
-        register(child, parent)
-      }
-    else if (self.is(CaseVal, butNot = Method | Module))
-      register(self, self.info)
-  }
-
   /** Does this symbol refer to anonymous classes synthesized by enum desugaring? */
   def isEnumAnonymClass(implicit ctx: Context): Boolean =
     self.isAnonymousClass && (self.owner.name.eq(nme.DOLLAR_NEW) || self.owner.is(CaseVal))
@@ -155,10 +134,12 @@ class SymUtils(val self: Symbol) extends AnyVal {
     self.isLocal && !cls.topLevelClass.isLinkedWith(self.topLevelClass)
 
   /** If this is a sealed class, its known children */
-  def children(implicit ctx: Context): List[Symbol] =
+  def children(implicit ctx: Context): List[Symbol] = {
+    if (self.isType) self.setFlag(ChildrenQueried)
     self.annotations.collect {
       case Annotation.Child(child) => child
     }
+  }
 
   def hasAnonymousChild(implicit ctx: Context): Boolean =
     children.exists(_ `eq` self)

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

@@ -18,6 +18,8 @@ import config.Printers.typr
 import Annotations._
 import Inferencing._
 import transform.ValueClasses._
+import transform.TypeUtils._
+import transform.SymUtils._
 import reporting.diagnostic.messages._
 
 trait NamerContextOps { this: Context =>
@@ -742,7 +744,10 @@ class Namer { typer: Typer =>
         assert(ctx.mode.is(Mode.Interactive), s"completing $denot in wrong run ${ctx.runId}, was created in ${creationContext.runId}")
         denot.info = UnspecifiedErrorType
       }
-      else completeInCreationContext(denot)
+      else {
+        completeInCreationContext(denot)
+        if (denot.isCompleted) registerIfChild(denot)
+      }
     }
 
     protected def addAnnotations(sym: Symbol): Unit = original match {
@@ -790,6 +795,39 @@ class Namer { typer: Typer =>
       }
     }
 
+    /** If completed symbol is an enum value or a named class, register it as a child
+     *  in all direct parent classes which are sealed.
+     */
+    def registerIfChild(denot: SymDenotation)(implicit ctx: Context): Unit = {
+      val sym = denot.symbol
+
+      def register(child: Symbol, parent: Type) = {
+        val cls = parent.classSymbol
+        if (cls.is(Sealed)) {
+          if ((child.isInaccessibleChildOf(cls) || child.isAnonymousClass) && !sym.hasAnonymousChild) {
+            cls.addAnnotation(Annotation.Child(cls))
+          }
+          else {
+            if (cls.is(ChildrenQueried))
+              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.""")
+            else {
+              //println(i"child $child of $cls")
+              cls.addAnnotation(Annotation.Child(child))
+            }
+          }
+        }
+      }
+
+      if (denot.isClass && !sym.isEnumAnonymClass && !sym.isRefinementClass)
+        denot.asClass.classParents.foreach { parent =>
+          val child = if (denot.is(Module)) denot.sourceModule else denot.symbol
+          register(child, parent)
+        }
+      else if (denot.is(CaseVal, butNot = Method | Module))
+        register(denot.symbol, denot.info)
+    }
+
     /** Intentionally left without `implicit ctx` parameter. We need
      *  to pick up the context at the point where the completer was created.
      */