Delay opaque alias checking until PostTyper

When we have a TypeBounds tree that also has an alias, we checked
that the alias is within bounds at Typer. This could provoke a
CyclicReference when processing opaque type aliases where
the type has a bound and also the alias refers back to the type.
We avoid the problem by performing the check at PostTyper, analogous
to other bounds checks.

Fixes scala#16642

Author: odersky

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

@@ -433,6 +433,13 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case SingletonTypeTree(ref) =>
           Checking.checkRealizable(ref.tpe, ref.srcPos)
           super.transform(tree)
+        case tree: TypeBoundsTree =>
+          val TypeBoundsTree(lo, hi, alias) = tree
+          if !alias.isEmpty then
+            val bounds = TypeBounds(lo.tpe, hi.tpe)
+            if !bounds.contains(alias.tpe) then
+              report.error(em"type ${alias.tpe} outside bounds $bounds", tree.srcPos)
+          super.transform(tree)
         case tree: TypeTree =>
           tree.withType(
             tree.tpe match {

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2164,10 +2164,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val alias1 = typed(alias)
     val lo2 = if (lo1.isEmpty) typed(untpd.TypeTree(defn.NothingType)) else lo1
     val hi2 = if (hi1.isEmpty) typed(untpd.TypeTree(defn.AnyType)) else hi1
-    if !alias1.isEmpty then
-      val bounds = TypeBounds(lo2.tpe, hi2.tpe)
-      if !bounds.contains(alias1.tpe) then
-        report.error(em"type ${alias1.tpe} outside bounds $bounds", tree.srcPos)
     assignType(cpy.TypeBoundsTree(tree)(lo2, hi2, alias1), lo2, hi2, alias1)
 
   def typedBind(tree: untpd.Bind, pt: Type)(using Context): Tree = {

tests/pos/recursive-opaques.scala

@@ -0,0 +1,12 @@
+object Syms:
+  import SymDs.*
+  opaque type Symbol <: AnyRef
+    = SymDenotation
+  opaque type ClassSymbol <: Symbol
+    = ClassDenotation
+
+object SymDs:
+  import Syms.*
+  class SymDenotation(sym: Symbol)
+  class ClassDenotation(sym: Symbol) extends SymDenotation(sym)
+