Divergence check uses HashMap

Author: Lluc24

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

@@ -3596,7 +3596,6 @@ object MatchReducer:
       case Stuck              => "Stuck"
       case NoInstance(fails)  => "NoInstance(" ~ Text(fails.map(p.toText(_) ~ p.toText(_)), ", ") ~ ")"
 
-  val Reduction = new Property.Key[Stack[Type]]
 
 /** A type comparer for reducing match types.
  *  TODO: Not sure this needs to be a type comparer. Can we make it a
@@ -3944,23 +3943,7 @@ class MatchReducer(initctx: Context) extends TypeComparer(initctx) {
             MatchTypeTrace.noInstance(scrut, cas, fails)
             NoType
           case MatchResult.Reduced(tp) =>
-            val reductionStack = ctx.property(Reduction) match
-              case Some(stack) => stack
-              case None     => Stack[Type]()
-
-            println(s"Scrutinee ${scrut.show}")
-            println(s"Reduction stack: ${reductionStack.map(_.show)}")
-
-            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 =
-                reductionStack.push(tp)
-                given Context = ctx.fresh.setProperty(Reduction, reductionStack)
-                tp.simplified
-              bodyType
+            tp.simplified
 
           case MatchResult.ReducedAndDisjoint =>
             // Empty types break the basic assumption that if a scrutinee and a

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

@@ -43,12 +43,16 @@ import cc.*
 import CaptureSet.IdentityCaptRefMap
 import Capabilities.*
 import transform.Recheck.currentRechecker
+import scala.collection.immutable.HashMap
+import dotty.tools.dotc.util.Property
 
 import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
 
 object Types extends TypeUtils {
 
+  val Reduction = new Property.Key[HashMap[Type, List[Type]]]
+
   @sharable private var nextId = 0
 
   implicit def eqType: CanEqual[Type, Type] = CanEqual.derived
@@ -1628,7 +1632,27 @@ object Types extends TypeUtils {
      *  then the result after applying all toplevel normalizations, otherwise NoType.
      */
     def tryNormalize(using Context): Type = underlyingNormalizable match
-      case mt: MatchType => mt.reduced.normalized
+      case mt: MatchType =>
+        this match
+          case self: AppliedType =>
+            println(i"Applied match type alias: ${self.tycon} with args ${self.args}")
+            println(i"Arguments Size: ${self.args.map(_.typeSize()).sum}")
+            // Check that if self.args is smaller than previous size for
+            // self.tycon if already set in the map
+            val reductionMap = ctx.property(Reduction) match
+              case Some(map) => map
+              case None     => HashMap[Type, List[Type]]()
+
+
+            if reductionMap.contains(self.tycon) && self.args.map(_.typeSize()).sum >= reductionMap(self.tycon).map(_.typeSize()).sum then
+              ErrorType(em"Non-decresing match type reduction detected: ${self.show}")
+            else
+              val result =
+                val newMap = reductionMap.updated(self.tycon, self.args)
+                given Context = ctx.fresh.setProperty(Reduction, newMap)
+                mt.reduced.normalized
+              result
+          case _ => mt.reduced.normalized
       case tp: AppliedType => tp.tryCompiletimeConstantFold
       case _ => NoType