(Potentially mis) use 'bounds' to limit recursion

Author: aherlihy

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

@@ -128,6 +128,7 @@ class TypeUtils:
         case None => throw new AssertionError("not a tuple")
 
     def namedTupleElementTypesUpTo(bound: Int, normalize: Boolean = true)(using Context): List[(TermName, Type)] =
+      if bound < 0 then Nil else
       (if normalize then self.normalized else self).dealias match
         case defn.NamedTuple(nmes, vals) =>
           val names = nmes.tupleElementTypesUpTo(bound, normalize).getOrElse(Nil).map(_.dealias).map:
@@ -136,14 +137,14 @@ class TypeUtils:
           val values = vals.tupleElementTypesUpTo(bound, normalize).getOrElse(Nil)
           names.zip(values)
         case tp: TypeProxy =>
-          tp.superType.namedTupleElementTypesUpTo(bound, normalize)
+          tp.superType.namedTupleElementTypesUpTo(bound - 1, normalize)
         case tp: OrType =>
-          val lhs = tp.tp1.namedTupleElementTypesUpTo(bound, normalize)
-          val rhs = tp.tp2.namedTupleElementTypesUpTo(bound, normalize)
+          val lhs = tp.tp1.namedTupleElementTypesUpTo(bound - 1, normalize)
+          val rhs = tp.tp2.namedTupleElementTypesUpTo(bound - 1, normalize)
           if (lhs.map(_._1) != rhs.map(_._1)) throw TypeError(em"Malformed Union Type: Named Tuple elements must be the same, but $lhs and $rhs were found.")
           lhs.zip(rhs).map((lhs, rhs) => (lhs._1, lhs._2 | rhs._2))
         case tp: AndType =>
-          (tp.tp1.namedTupleElementTypesUpTo(bound, normalize), tp.tp2.namedTupleElementTypesUpTo(bound, normalize)) match
+          (tp.tp1.namedTupleElementTypesUpTo(bound - 1, normalize), tp.tp2.namedTupleElementTypesUpTo(bound - 1, normalize)) match
             case (Nil, rhs) => rhs
             case (lhs, Nil) => lhs
             case (lhs, rhs) =>