Fix cyclicity error for self-referential enum case

Fixes #11443

When an enum case references itself in a parent type (e.g.,
`case Nn extends Opt[Nothing] with Comparable[Nn.type]`), the
compiler previously reported a cyclic reference error during type
inference.

The issue occurred because:
1. The enum case `Nn` is desugared to a lazy val without an explicit type
2. Type inference requires typing the RHS (an anonymous class)
3. Typing the parent `Comparable[Nn.type]` requires accessing `Nn`'s type
4. This triggers `Nn`'s completer while it's already being completed

The fix detects self-references in enum case parents and provides an
explicit type annotation (the first parent, which is always the enum
type) to break the cycle. This allows the compiler to resolve `Nn.type`
without triggering recursive completion.

The explicit type is only added when there's actually a self-reference,
so normal enum cases continue to have their full type inferred as before.

Author: bracevac

compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala

@@ -289,7 +289,27 @@ object DesugarEnums {
       val (tag, scaffolding) = nextOrdinal(name, CaseKind.Object, definesLookups)
       val impl1 = cpy.Template(impl)(parents = impl.parents :+ scalaRuntimeDot(tpnme.EnumValue), body = Nil)
         .withAttachment(ExtendsSingletonMirror, ())
-      val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods.withAddedFlags(EnumValue, span))
+
+      // Check if any parent contains a reference to this enum case name
+      def containsNameRef(tree: Tree): Boolean = tree match {
+        case Ident(n) if n == name => true
+        case Select(qual, _) => containsNameRef(qual)
+        case AppliedTypeTree(tpt, args) => containsNameRef(tpt) || args.exists(containsNameRef)
+        case SingletonTypeTree(ref) => containsNameRef(ref)
+        case _ => false
+      }
+
+      // Only provide explicit type if there's a self-reference to avoid cycles
+      // (e.g., `case Nn extends Opt[Nothing] with Comparable[Nn.type]`)
+      val tpt =
+        if impl.parents.exists(containsNameRef) then
+          // Use first parent (the enum type) as explicit type to break the cycle
+          impl.parents.headOption.getOrElse(TypeTree())
+        else
+          // No self-reference, let the type be inferred normally
+          TypeTree()
+
+      val vdef = ValDef(name, tpt, New(impl1)).withMods(mods.withAddedFlags(EnumValue, span))
       flatTree(vdef :: scaffolding).withSpan(span)
     }
   }

tests/pos/i11443.scala

@@ -0,0 +1,5 @@
+enum Opt[T] {
+  case Nn extends Opt[Nothing] with Comparable[Nn.type]
+
+  def compareTo(nn: Nn.type) = 0
+}