Remove use of simplified in MT reduction

I gave match type's redux an extension to the normalize algorithm, in
order to make the test suite pass, as well as add an extra recursion to
the simplify algorithm.  A few neg tests tweaked and some other code
changes could be dropped.

Author: dwijnand

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

@@ -3136,15 +3136,15 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
         case param @ TypeParamRef(b, n) if b eq caseLambda =>
           insts(n) =
             if canApprox then
-              approximation(param, fromBelow = variance >= 0, Int.MaxValue).simplified
+              approximation(param, fromBelow = variance >= 0, Int.MaxValue).normalized
             else constraint.entry(param) match
               case entry: TypeBounds =>
                 val lo = fullLowerBound(param)
                 val hi = fullUpperBound(param)
-                if !poisoned(param) && isSubType(hi, lo) then lo.simplified else Range(lo, hi)
+                if !poisoned(param) && isSubType(hi, lo) then lo.normalized else Range(lo, hi)
               case inst =>
                 assert(inst.exists, i"param = $param\nconstraint = $constraint")
-                if !poisoned(param) then inst.simplified else Range(inst, inst)
+                if !poisoned(param) then inst.normalized else Range(inst, inst)
           insts
         case _ =>
           foldOver(insts, t)
@@ -3166,6 +3166,11 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
       }
     }
 
+    def normalizeHard(tp: Type): Type = tp.tryNormalize.orElse(tp match {
+      case tp: AppliedType => tp.map(normalizeHard)
+      case _               => tp
+    })
+
     /** Match a single case. */
     def matchCase(cas: Type): MatchResult = trace(i"$scrut match ${MatchTypeTrace.caseText(cas)}", matchTypes, show = true) {
       val cas1 = cas match {
@@ -3229,7 +3234,7 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
             MatchTypeTrace.noInstance(scrut, cas, fails)
             NoType
           case MatchResult.Reduced(tp) =>
-            tp.simplified
+            normalizeHard(tp)
       case Nil =>
         val casesText = MatchTypeTrace.noMatchesText(scrut, cases)
         ErrorType(reporting.MatchTypeNoCases(casesText))

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

@@ -147,7 +147,7 @@ object TypeOps:
             isFullyDefined(tp, ForceDegree.all)
           case _ =>
         val normed = tp.tryNormalize
-        if normed.exists then normed else tp.map(simplify(_, theMap))
+        if normed.exists then simplify(normed, theMap) else tp.map(simplify(_, theMap))
       case tp: TypeParamRef =>
         val tvar = ctx.typerState.constraint.typeVarOfParam(tp)
         if tvar.exists then tvar else tp
@@ -184,7 +184,7 @@ object TypeOps:
         else tp.derivedAnnotatedType(parent1, annot)
       case _: MatchType =>
         val normed = tp.tryNormalize
-        if (normed.exists) normed else mapOver
+        if (normed.exists) simplify(normed, theMap) else mapOver
       case tp: MethodicType =>
         // See documentation of `Types#simplified`
         val addTypeVars = new TypeMap with IdempotentCaptRefMap:

compiler/test/dotc/pos-test-pickling.blacklist

@@ -51,6 +51,7 @@ i15158.scala
 i15155.scala
 i15827.scala
 i17149.scala
+tuple-fold.scala
 
 # Opaque type
 i5720.scala