Handle anonymous classes with Child(self)

If a sealed class A has local or anonymous classes, add the
annotation `Child(A)` to `A`. With this simple change, the
exhaustivity check works without any modification.

Author: liufengyun

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -842,10 +842,7 @@ class TreeUnpickler(reader: TastyReader,
       if (!sym.isType) { // Only terms might have leaky aliases, see the documentation of `checkNoPrivateLeaks`
         sym.info = ta.avoidPrivateLeaks(sym, tree.pos)
       }
-      if ((sym.isClass || sym.is(CaseVal)) && sym.isLocal)
-        // Child annotations for local classes and enum values are not pickled, so
-        // need to be re-established here.
-        sym.registerIfChild(late = true)
+
       sym.defTree = tree
 
       if (ctx.mode.is(Mode.ReadComments)) {

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

@@ -133,14 +133,15 @@ class SymUtils(val self: Symbol) extends AnyVal {
 
   /** If this symbol is an enum value or a named class, register it as a child
    *  in all direct parent classes which are sealed.
-   *   @param  @late  If true, register only inaccessible children (all others are already
-   *                  entered at this point).
    */
-  def registerIfChild(late: Boolean = false)(implicit ctx: Context): Unit = {
+  def registerIfChild()(implicit ctx: Context): Unit = {
     def register(child: Symbol, parent: Type) = {
       val cls = parent.classSymbol
-      if (cls.is(Sealed) && (!late || child.isInaccessibleChildOf(cls)))
-        cls.addAnnotation(Annotation.Child(child))
+      if (cls.is(Sealed)) {
+        if ((child.isLocal || 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 =>
@@ -168,6 +169,9 @@ class SymUtils(val self: Symbol) extends AnyVal {
       case Annotation.Child(child) => child
     }
 
+  def hasAnonymousChild(implicit ctx: Context): Boolean =
+    children.exists(_ `eq` self)
+
   /** Is symbol directly or indirectly owned by a term symbol? */
   @tailrec final def isLocal(implicit ctx: Context): Boolean = {
     val owner = self.owner

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -730,6 +730,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     val res =
       (tp.classSymbol.is(Sealed) &&
         tp.classSymbol.is(AbstractOrTrait) &&
+        !tp.classSymbol.hasAnonymousChild &&
         tp.classSymbol.children.nonEmpty ) ||
       dealiasedTp.isInstanceOf[OrType] ||
       (dealiasedTp.isInstanceOf[AndType] && {