ordinal: drop unchecked with sealed abstract skips

In the `ordinal` method, drop the use of `@unchecked` by skipping
children that are sealed traits or sealed abstract classes and don't
have any anonymous subclasses.

The `@unchecked` I added in ee5a82f.
In a PR to specifically with reachability I started similar warnings in
`ordinal` (this was before adding `@unchecked` was merged) so I'm hoping
with this patch to avoid the false positives properly.

Author: dwijnand

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

@@ -2526,10 +2526,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         case _ => false
       })
 
-    /** Can we enumerate all instantiations of this type? */
-    def isClosedSum(tp: Symbol): Boolean =
-      tp.is(Sealed) && tp.isOneOf(AbstractOrTrait) && !tp.hasAnonymousChild
-
     /** Splits a closed type into a disjunction of smaller types.
      *  It should hold that `tp` and `decompose(tp).reduce(_ or _)`
      *  denote the same set of values.
@@ -2570,9 +2566,9 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             // subtype, so they must be unrelated by single inheritance
             // of classes.
             true
-          else if (isClosedSum(cls1))
+          else if (cls1.isClosedSum)
             decompose(cls1, tp1).forall(x => provablyDisjoint(x, tp2))
-          else if (isClosedSum(cls2))
+          else if (cls2.isClosedSum)
             decompose(cls2, tp2).forall(x => provablyDisjoint(x, tp1))
           else
             false

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

@@ -246,6 +246,10 @@ object SymUtils:
     def hasAnonymousChild(using Context): Boolean =
       self.children.exists(_ `eq` self)
 
+    /** Can we enumerate all instantiations of this type? */
+    def isClosedSum(using Context): Boolean =
+      self.is(Sealed) && self.isOneOf(AbstractOrTrait) && !self.hasAnonymousChild
+
     /** Is this symbol directly owner by a term symbol, i.e., is it local to a block? */
     def isLocalToBlock(using Context): Boolean =
       self.owner.isTerm

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

@@ -517,13 +517,19 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
   def ordinalBody(cls: Symbol, param: Tree)(using Context): Tree =
     if (cls.is(Enum)) param.select(nme.ordinal).ensureApplied
     else {
+      def collect(children: List[Symbol], seen: Set[Symbol], acc: List[Symbol]): List[Symbol] = children match {
+        case c :: rest if seen(c)       => collect(rest, seen, acc)
+        case c :: rest if c.isClosedSum => collect(c.children ::: rest, seen + c, acc)
+        case c :: rest                  => collect(rest, seen + c, c :: acc)
+        case _                          => acc
+      }
       val cases =
-        for ((child, idx) <- cls.children.zipWithIndex) yield {
+        for ((child, idx) <- collect(List(cls), Set(), Nil).reverseIterator.zipWithIndex) yield {
           val patType = if (child.isTerm) child.reachableTermRef else child.reachableRawTypeRef
-          val pat = Typed(untpd.Ident(nme.WILDCARD).withType(patType), TypeTree(patType))
+          val pat = Typed(Underscore(patType), TypeTree(patType))
           CaseDef(pat, EmptyTree, Literal(Constant(idx)))
         }
-      Match(param.annotated(New(defn.UncheckedAnnot.typeRef, Nil)), cases)
+      Match(param, cases.toList)
     }
 
   /** - If `impl` is the companion of a generic sum, add `deriving.Mirror.Sum` parent

tests/run-custom-args/fatal-warnings/i11050.scala

@@ -79,9 +79,9 @@ object Test:
     val d         = D()
     val e         = E()
 
-    assertEq(List(d, e).map(m.ordinal), List(0, 0))
+    assertEq(List(d, e).map(m.ordinal), List(0, 1))
     assertShow[A](d, "[0] [0] D")
-    assertShow[A](e, "[0] [1] E")
+    assertShow[A](e, "[1] [1] E")
   end testFromAkkaCB
 
   def testFromAkkaCB2() =