Fix #10867: Normalize after applyIfParameterized in superType

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

@@ -4105,18 +4105,17 @@ object Types {
 
     override def underlying(using Context): Type = tycon
 
-    override def superType(using Context): Type = {
-      if (ctx.period != validSuper) {
-        cachedSuper = tycon match {
+    override def superType(using Context): Type =
+      if ctx.period != validSuper then
+        validSuper = if (tycon.isProvisional) Nowhere else ctx.period
+        cachedSuper = tycon match
           case tycon: HKTypeLambda => defn.AnyType
           case tycon: TypeRef if tycon.symbol.isClass => tycon
-          case tycon: TypeProxy => tycon.superType.applyIfParameterized(args)
+          case tycon: TypeProxy =>
+            if isMatchAlias then validSuper = Nowhere
+            tycon.superType.applyIfParameterized(args).normalized
           case _ => defn.AnyType
-        }
-        validSuper = if (tycon.isProvisional) Nowhere else ctx.period
-      }
       cachedSuper
-    }
 
     override def translucentSuperType(using Context): Type = tycon match {
       case tycon: TypeRef if tycon.symbol.isOpaqueAlias =>

tests/pos-deep-subtype/9849.scala → tests/neg-custom-args/allow-deep-subtypes/9849.scala

@@ -1,4 +1,4 @@
-type *:[A, B] = A match
+type *:[A, B] = A match // error: Recursion limit exceeded.
   case (B *: x) => A
   case (x *: y) => x *: (B *: y)
   case _ => A *: B

tests/pos/10867.scala

@@ -0,0 +1,49 @@
+object Test {
+  type inserts[a, as <: Tuple] <: Tuple =
+    as match
+      case EmptyTuple => (a *: EmptyTuple) *: EmptyTuple
+      case y *: ys => (a *: y *: ys) *: Tuple.Map[inserts[a, ys], [t <: Tuple] =>> y *: t]
+
+  type inserts2[a] =
+    [as <: Tuple] =>> inserts[a, as]
+
+  type A = inserts [1, EmptyTuple]
+  type B = inserts2[1][EmptyTuple]
+
+  summon[A =:= ((1 *: EmptyTuple) *: EmptyTuple)]
+  summon[B =:= ((1 *: EmptyTuple) *: EmptyTuple)]
+  summon[A =:= B]
+
+  type H[t <: Tuple] = Tuple.Concat[t, EmptyTuple]
+
+  summon[H[A] =:= H[B]]
+
+  summon[Tuple.Concat[A, EmptyTuple] =:= Tuple.Concat[B, EmptyTuple]]
+}
+
+object Minimized {
+  type Concombre[X <: Tuple, +Y <: Tuple] <: Tuple = X match {
+    case EmptyTuple => Y
+    case x1 *: xs1 => X
+  }
+
+  type inserts[a, as <: Tuple] <: Tuple =
+    as match
+      case EmptyTuple => a *: EmptyTuple
+
+  type inserts2[a] =
+    [as <: Tuple] =>> inserts[a, as]
+
+  type A = inserts [1, EmptyTuple]
+  type B = inserts2[1][EmptyTuple]
+  type C = 1 *: EmptyTuple
+
+  summon[A =:= B]
+  summon[A =:= C]
+  summon[B =:= C]
+
+  type H[t <: Tuple] = Concombre[t, EmptyTuple]
+
+  summon[H[C] =:= H[A]]
+  summon[H[C] =:= H[B]]
+}