Fix #9000: Avoid spurious cyclic errors for typelevel matches

I still don't know why the match type
```
type A2B[Xs <: Tuple] <: Tuple = Xs match
  case Unit => Unit
  case a *: as => B *: A2B[as]
```
compiled OK if it appeared in a user defined object, but failed with a cyclic
reference when written on the top level. But the logic for cyclic detection was
clearly very fragile, and unadapted to the case at hand. Essentially, it's a
type map that inserts LazyRefs when it detects legal cycles. The problem is that
these insertions cause recomputations of applied types in the TypeMap. And these
fail since the type constructor (A2B in this case) has not yet been completed.
So after a LazyRef was inserted, the cycle checker fails again in an unrecoverable
way because it tries to get the type parameters of an uncompleted type constructor.
So the question would be rather - why did this work if the match type appears in
a user-defined object? I could not answer that question, but I could fix the logic
to handle these cases.

Author: odersky

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

@@ -157,7 +157,11 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final class SubstBindingMap(from: BindingType, to: BindingType) extends DeepTypeMap {
+  /** SubstBinding is called from checkNotCyclic at a point where the
+   *  type constructor of an applied type might not be completed yet.
+   *  Therefore it needs to be a SimpleMap. Test case is toplevel-match.scala
+   */
+  final class SubstBindingMap(from: BindingType, to: BindingType) extends DeepTypeMap, SimpleTypeMap {
     def apply(tp: Type): Type = subst(tp, from, to, this)
   }
 

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

@@ -4888,6 +4888,19 @@ object Types {
     protected def derivedLambdaType(tp: LambdaType)(formals: List[tp.PInfo], restpe: Type): Type =
       tp.derivedLambdaType(tp.paramNames, formals, restpe)
 
+    protected def mapAppliedType(tp: AppliedType): Type =
+      def mapArgs(args: List[Type], tparams: List[ParamInfo]): List[Type] = args match
+        case arg :: otherArgs if tparams.nonEmpty =>
+          val arg1 = arg match
+            case arg: TypeBounds => this(arg)
+            case arg => atVariance(variance * tparams.head.paramVarianceSign)(this(arg))
+          val otherArgs1 = mapArgs(otherArgs, tparams.tail)
+          if ((arg1 eq arg) && (otherArgs1 eq otherArgs)) args
+          else arg1 :: otherArgs1
+        case nil =>
+          nil
+      derivedAppliedType(tp, this(tp.tycon), mapArgs(tp.args, tp.tyconTypeParams))
+
     /** Map this function over given type */
     def mapOver(tp: Type): Type = {
       record(s"mapOver ${getClass}")
@@ -4911,19 +4924,7 @@ object Types {
           | NoPrefix => tp
 
         case tp: AppliedType =>
-          def mapArgs(args: List[Type], tparams: List[ParamInfo]): List[Type] = args match {
-            case arg :: otherArgs if tparams.nonEmpty =>
-              val arg1 = arg match {
-                case arg: TypeBounds => this(arg)
-                case arg => atVariance(variance * tparams.head.paramVarianceSign)(this(arg))
-              }
-              val otherArgs1 = mapArgs(otherArgs, tparams.tail)
-              if ((arg1 eq arg) && (otherArgs1 eq otherArgs)) args
-              else arg1 :: otherArgs1
-            case nil =>
-              nil
-          }
-          derivedAppliedType(tp, this(tp.tycon), mapArgs(tp.args, tp.tyconTypeParams))
+          mapAppliedType(tp)
 
         case tp: RefinedType =>
           derivedRefinedType(tp, this(tp.parent), this(tp.refinedInfo))
@@ -5037,6 +5038,31 @@ object Types {
     }
   }
 
+  /** A type map with simplified handling of applied types. Arguments are mapped
+   *  without regard to variance and the applied type is reconsitituted without
+   *  going through derivedAppliedType. This could have performance benefits, and
+   *  it also does not force the type constructor's info. The second aspect is
+   *  needed when checking for cycles in Namer, since the type constructor is
+   *  not completed yet at this point. 
+   */  
+  trait SimpleTypeMap extends TypeMap:
+
+    override protected def mapAppliedType(tp: AppliedType): Type =
+      def mapArgs(args: List[Type]): List[Type] = args match
+        case arg :: otherArgs =>
+          val arg1 = this(arg)
+          val otherArgs1 = mapArgs(otherArgs)
+          if ((arg1 eq arg) && (otherArgs1 eq otherArgs)) args
+          else arg1 :: otherArgs1
+        case nil =>
+          nil
+      val tycon1 = this(tp.tycon)
+      val args1 = mapArgs(tp.args)
+      if (tycon1 eq tp.tycon) && (args1 eq tp.args) then tp
+      else AppliedType(tycon1, args1)
+
+  end SimpleTypeMap
+
   /** A type map that maps also parents and self type of a ClassInfo */
   abstract class DeepTypeMap(implicit ctx: Context) extends TypeMap {
     override def mapClassInfo(tp: ClassInfo): ClassInfo = {

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

@@ -266,7 +266,11 @@ object Checking {
         this(tp.info)
         mapOver(tp)
       case tp @ AppliedType(tycon, args) =>
-        tp.derivedAppliedType(this(tycon), args.mapConserve(this(_, nestedCycleOK, nestedCycleOK)))
+        val tycon1 = this(tycon)
+        val args1 = args.mapConserve(this(_, nestedCycleOK, nestedCycleOK))
+        if (tycon1 eq tycon) && (args1 eq args) then tp
+        else AppliedType(tycon1, args1)
+          // don't go through derivedAppliedType sine tycon might not be completed yet
       case tp @ RefinedType(parent, name, rinfo) =>
         tp.derivedRefinedType(this(parent), name, this(rinfo, nestedCycleOK, nestedCycleOK))
       case tp: RecType =>
@@ -334,7 +338,7 @@ object Checking {
 
   /** Check that `info` of symbol `sym` is not cyclic.
    *  @pre     sym is not yet initialized (i.e. its type is a Completer).
-   *  @return  `info` where every legal F-bounded reference is proctected
+   *  @return  `info` where every legal F-bounded reference is protected
    *                  by a `LazyRef`, or `ErrorType` if a cycle was detected and reported.
    */
   def checkNonCyclic(sym: Symbol, info: Type, reportErrors: Boolean)(using Context): Type = {

tests/pos/toplevel-match.scala

@@ -0,0 +1,14 @@
+class A
+class B
+
+trait HList
+class HCons[A, As <: HList] extends HList
+class HNil[A] extends HList
+
+type AtoB[Xs <: HList] <: HList = Xs match
+  case HNil[a] => HNil[B]
+  case HCons[a, as] => HCons[B, AtoB[as]]
+
+type A2B[Xs <: Tuple] <: Tuple = Xs match
+  case Unit => Unit
+  case a *: as => B *: A2B[as]