Implement MatchType reduction avoidance on typeSize

Author: Lluc24

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

@@ -3944,21 +3944,22 @@ class MatchReducer(initctx: Context) extends TypeComparer(initctx) {
             MatchTypeTrace.noInstance(scrut, cas, fails)
             NoType
           case MatchResult.Reduced(tp) =>
-            val reductionStatus = ctx.property(Reduction) match
+            val reductionStack = ctx.property(Reduction) match
               case Some(stack) => stack
               case None     => Stack[Type]()
 
             println(s"Scrutinee ${scrut.show}")
-            println(s"Reduction stack: ${reductionStatus.map(_.show)}")
+            println(s"Reduction stack: ${reductionStack.map(_.show)}")
 
-            if reductionStatus.contains(tp) then
+            if reductionStack.contains(tp) then
               ErrorType(em"Cyclic match type reduction detected")
+            else if !reductionStack.isEmpty && tp.typeSize(false) > reductionStack.top.typeSize(false) then
+              ErrorType(em"Non-decresing match type reduction detected: ${tp.show}")
             else
-              val bodyType = {
-                reductionStatus.push(tp)
-                given Context = ctx.fresh.setProperty(Reduction, reductionStatus)
+              val bodyType =
+                reductionStack.push(tp)
+                given Context = ctx.fresh.setProperty(Reduction, reductionStack)
                 tp.simplified
-              }
               bodyType
 
           case MatchResult.ReducedAndDisjoint =>

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

@@ -2095,8 +2095,8 @@ object Types extends TypeUtils {
       (new CoveringSetAccumulator).apply(Set.empty[Symbol], this)
 
     /** The number of applications and refinements in this type, after all aliases are expanded */
-    def typeSize(using Context): Int =
-      (new TypeSizeAccumulator).apply(0, this)
+    def typeSize(normalizeMatchTypes: Boolean = true)(using Context): Int =
+      (new TypeSizeAccumulator).apply(0, this, normalizeMatchTypes)
 
     /** Convert to text */
     def toText(printer: Printer): Text = printer.toText(this)
@@ -7123,12 +7123,16 @@ object Types extends TypeUtils {
 
   class TypeSizeAccumulator(using Context) extends TypeAccumulator[Int] {
     var seen = util.HashSet[Type](initialCapacity = 8)
-    def apply(n: Int, tp: Type): Int =
+    def apply(n: Int, tp: Type, normalizeMatchTypes: Boolean): Int =
       tp match {
         case tp: AppliedType =>
-          val tpNorm = tp.tryNormalize
-          if tpNorm.exists then apply(n, tpNorm)
-          else foldOver(n + 1, tp)
+          if !normalizeMatchTypes && tp.isMatchAlias then
+            println(s"TypeSizeAccumulator: skipping match alias ${tp.show}")
+            foldOver(n + 1, tp)
+          else
+            val tpNorm = tp.tryNormalize
+            if tpNorm.exists then apply(n, tpNorm)
+            else foldOver(n + 1, tp)
         case tp: RefinedType =>
           foldOver(n + 1, tp)
         case tp: TypeRef if tp.info.isTypeAlias =>
@@ -7146,6 +7150,8 @@ object Types extends TypeUtils {
         case _ =>
           foldOver(n, tp)
       }
+
+    def apply(n: Int, tp: Type): Int = apply(n, tp, normalizeMatchTypes = false)
   }
 
   class CoveringSetAccumulator(using Context) extends TypeAccumulator[Set[Symbol]] {

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

@@ -1827,7 +1827,7 @@ trait Implicits:
 
     /** Fields needed for divergence checking */
     @threadUnsafe lazy val ptCoveringSet = wideProto.coveringSet
-    @threadUnsafe lazy val ptSize = wideProto.typeSize
+    @threadUnsafe lazy val ptSize = wideProto.typeSize()
     @threadUnsafe lazy val wildPt = wildApprox(wideProto)
 
     /**
@@ -1967,7 +1967,7 @@ case class OpenSearch(cand: Candidate, pt: Type, outer: SearchHistory)(using Con
   // by nested implicit searches, thus leading to types in search histories
   // that grow larger the deeper the search gets. This can mask divergence.
   // An example is in neg/9504.scala
-  lazy val typeSize = pt.typeSize
+  lazy val typeSize = pt.typeSize()
   lazy val coveringSet = pt.coveringSet
 end OpenSearch
 

compiler/test/dotty/tools/dotc/typer/DivergenceChecker.scala

@@ -56,7 +56,7 @@ class DivergenceCheckerTests extends DottyTest {
 
         tpes.lazyZip(expectedSizes).lazyZip(expectedCoveringSets).foreach {
           case (tpe, expectedSize, expectedCoveringSet) =>
-            val size = tpe.typeSize
+            val size = tpe.typeSize()
             val cs = tpe.coveringSet
 
             assertTrue(size == expectedSize)