Fix #9069: Complete children of sealed classes before querying

Complete all possible children of sealed classes or traits before first querying
with `children`. This way we make they register themselves with Child annotations
in the parent class.

Author: odersky

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

@@ -1578,6 +1578,32 @@ object SymDenotations {
       if (is(Private))
         copySymDenotation(name = expandedName, initFlags = this.flags &~ Private)
       else this
+
+    /** If this is a sealed class, its known children in the order of textual occurrence
+     */
+    def children(using Context): List[Symbol] =
+
+      def completeChildrenIn(owner: Symbol) =
+        def maybeChild(c: Symbol) =
+          !owner.is(Package)
+          || c.infoOrCompleter.match
+              case _: SymbolLoaders.SecondCompleter => c.associatedFile == symbol.associatedFile
+              case _ => false
+        if owner.isClass then
+          for c <- owner.info.decls.toList if c.isClass && maybeChild(c) do
+            c.ensureCompleted()
+
+      if is(Sealed) then
+        if !is(ChildrenQueried) && !ctx.isAfterTyper then
+          // During typer, make sure all visible children are completed, so that
+          // they show up in Child annotations. A class is visible if it is defined
+          // in the same scope as `cls` or in the companion object of `cls`.
+          completeChildrenIn(owner)
+          completeChildrenIn(companionClass)
+          setFlag(ChildrenQueried)
+
+      annotations.collect { case Annotation.Child(child) => child }.reverse
+    end children
   }
 
   /** The contents of a class definition during a period

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -1780,7 +1780,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
     }
 
   def Symbol_children(self: Symbol)(using ctx: Context): List[Symbol] =
-    dotty.tools.dotc.transform.SymUtils(self).children
+    self.children
 
   private def isField(sym: Symbol)(using ctx: Context): Boolean = sym.isTerm && !sym.is(Flags.Method)
 

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

@@ -188,21 +188,8 @@ class SymUtils(val self: Symbol) extends AnyVal {
         || sym.isType && isAccessible(sym.owner, cls)
     !isAccessible(self.owner, cls)
 
-  /** 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)
-
-    if (self.isAllOf(JavaEnumTrait))
-      self.linkedClass.info.decls.foreach(_.ensureCompleted())
-
-    self.annotations.collect {
-      case Annotation.Child(child) => child
-    }.reverse
-  }
-
   def hasAnonymousChild(implicit ctx: Context): Boolean =
-    children.exists(_ `eq` self)
+    self.children.exists(_ `eq` self)
 
   /** Is symbol directly or indirectly owned by a term symbol? */
   @tailrec final def isLocal(implicit ctx: Context): Boolean = {

tests/pos/i9069/Test.scala

@@ -0,0 +1,3 @@
+def Test =
+  val mirror = summon[deriving.Mirror.SumOf[Foo]]
+  summon[mirror.MirroredElemTypes =:= (Foo.Baz.type, Bar)]

tests/pos/i9069/Wrapper.scala

@@ -0,0 +1,4 @@
+sealed trait Foo
+object Foo:
+  case object Baz extends Foo
+case class Bar(x: Int) extends Foo