Revert "Approximate MatchTypes with lub of case bodies, if non-recursive"

Author: WojciechMazur

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

@@ -2897,13 +2897,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         tp
       case tp: HKTypeLambda =>
         tp
-      case tp: ParamRef =>
-        val st = tp.superTypeNormalized
-        if st.exists then
-          disjointnessBoundary(st)
-        else
-          // workaround for when ParamRef#underlying returns NoType
-          defn.AnyType
       case tp: TypeProxy =>
         disjointnessBoundary(tp.superTypeNormalized)
       case tp: WildcardType =>

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

@@ -2389,15 +2389,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       report.error(MatchTypeScrutineeCannotBeHigherKinded(sel1Tpe), sel1.srcPos)
     val pt1 = if (bound1.isEmpty) pt else bound1.tpe
     val cases1 = tree.cases.mapconserve(typedTypeCase(_, sel1Tpe, pt1))
-    val bound2 = if tree.bound.isEmpty then
-      val lub = cases1.foldLeft(defn.NothingType: Type): (acc, case1) =>
-        if !acc.exists then NoType
-        else if case1.body.tpe.isProvisional then NoType
-        else acc | case1.body.tpe
-      if lub.exists then TypeTree(lub, inferred = true)
-      else bound1
-    else bound1
-    assignType(cpy.MatchTypeTree(tree)(bound2, sel1, cases1), bound2, sel1, cases1)
+    assignType(cpy.MatchTypeTree(tree)(bound1, sel1, cases1), bound1, sel1, cases1)
   }
 
   def typedByNameTypeTree(tree: untpd.ByNameTypeTree)(using Context): ByNameTypeTree = tree.result match

tests/pos/13633.scala

@@ -21,7 +21,7 @@ object Sums extends App:
 
   type Reverse[A] = ReverseLoop[A, EmptyTuple]
 
-  type PlusTri[A, B, C] <: Tuple                    = (A, B, C) match
+  type PlusTri[A, B, C]                             = (A, B, C) match
     case (false, false, false)                                              => (false, false)
     case (true, false, false) | (false, true, false) | (false, false, true) => (false, true)
     case (true, true, false) | (true, false, true) | (false, true, true)    => (true, false)