Refine criterion when to complete children

Author: odersky

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

@@ -339,7 +339,7 @@ object Flags {
   val (_, DefaultMethod @ _, _) = newFlags(38, "<defaultmethod>")
 
   /** Symbol is an enum class or enum case (if used with case) */
-  val (Enum @ _, _, _) = newFlags(40, "enum")
+  val (Enum @ _, EnumVal @ _, _) = newFlags(40, "enum")
 
   /** An export forwarder */
   val (Exported @ _, _, _) = newFlags(41, "exported")
@@ -530,7 +530,7 @@ object Flags {
   val DeferredOrLazyOrMethod: FlagSet        = Deferred | Lazy | Method
   val DeferredOrTermParamOrAccessor: FlagSet = Deferred | ParamAccessor | TermParam           // term symbols without right-hand sides
   val DeferredOrTypeParam: FlagSet           = Deferred | TypeParam                           // type symbols without right-hand sides
-  val EnumValue: FlagSet                     = Enum | StableRealizable           // A Scala enum value
+  val EnumValue: FlagSet                     = Enum | StableRealizable                        // A Scala enum value
   val StableOrErased: FlagSet                = Erased | StableRealizable                      // Assumed to be pure
   val ExtensionMethod: FlagSet               = Extension | Method
   val FinalOrInline: FlagSet                 = Final | Inline

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

@@ -1583,23 +1583,32 @@ object SymDenotations {
      */
     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
+      def completeChildrenIn(owner: Symbol)(using Context) =
+        // Possible children are: classes extending Scala classes and
+        // Scala or Java enum values that are defined in owner.
+        // If owner is a package, we complete only
+        // children that are defined in the same file as their parents.
+        def maybeChild(sym: Symbol) =
+          (sym.isClass && !this.is(JavaDefined) || sym.is(EnumVal))
+          && !owner.is(Package)
+             || sym.infoOrCompleter.match
+                  case _: SymbolLoaders.SecondCompleter => sym.associatedFile == this.symbol.associatedFile
+                  case _ => false
+
         if owner.isClass then
-          for c <- owner.info.decls.toList if c.isClass && maybeChild(c) do
+          for c <- owner.info.decls.toList if maybeChild(c) do
             c.ensureCompleted()
+      end completeChildrenIn
 
       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)
+        if !is(ChildrenQueried) then
+          // Make sure all visible children are completed, so that
+          // they show up in Child annotations. A possible child is visible if it
+          // is defined in the same scope as `cls` or in the companion object of `cls`.
+          inContext(ctx.withPhase(ctx.typerPhase)) {
+            completeChildrenIn(owner)
+            completeChildrenIn(companionClass)
+          }
           setFlag(ChildrenQueried)
 
       annotations.collect { case Annotation.Child(child) => child }.reverse