Simplify MT reduction algorithm

By removing the widenAbstractTypes step, which is subsumed by the
provably empty test.

Author: OlivierBlanvillain

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

@@ -2409,34 +2409,6 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
         case _ =>
           cas
       }
-      def widenAbstractTypes(tp: Type): Type = new TypeMap {
-        var seen = Set[TypeParamRef]()
-        def apply(tp: Type) = tp match {
-          case tp: TypeRef =>
-            tp.info match {
-              case info: MatchAlias =>
-                mapOver(tp)
-                  // TODO: We should follow the alias in this case, but doing so
-                  // risks infinite recursion
-              case TypeBounds(lo, hi) =>
-                if (hi frozen_<:< lo) {
-                  val alias = apply(lo)
-                  if (alias ne lo) alias else mapOver(tp)
-                }
-                else WildcardType
-              case _ =>
-                mapOver(tp)
-            }
-          case tp: TypeLambda =>
-            val saved = seen
-            seen ++= tp.paramRefs
-            try mapOver(tp)
-            finally seen = saved
-          case tp: TypeVar if !tp.isInstantiated => WildcardType
-          case tp: TypeParamRef if !seen.contains(tp) => WildcardType
-          case _ => mapOver(tp)
-        }
-      }.apply(tp)
 
       val defn.MatchCase(pat, body) = cas1
 
@@ -2451,8 +2423,6 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
               body
           }
         }
-      else if (isSubType(widenAbstractTypes(scrut), widenAbstractTypes(pat)))
-        Some(NoType)
       else if (provablyDisjoint(scrut, pat))
         // We found a proof that `scrut` and `pat` are incompatible.
         // The search continues.

tests/neg-custom-args/matchtype-loop.scala

@@ -2,7 +2,7 @@ object Test {
   type L[X] = X match {
     case Int => L[X]
   }
-  type LL[X] = X match {  // error: recursion limit exceeded
+  type LL[X] = X match {
     case Int => LL[LL[X]]
   }
   def a: L[Boolean] = ???

tests/neg/6314-6.scala

@@ -0,0 +1,62 @@
+final class X
+final class Y
+
+object Test3 {
+  type Bar[A] = A match {
+    case X => String
+    case Y => Int
+  }
+
+  trait XX {
+    type Foo
+
+    val a: Bar[X & Foo] = "hello"
+    val b: Bar[Y & Foo] = 1
+
+    def apply(fa: Bar[X & Foo]): Bar[Y & Foo]
+
+    def boom: Int = apply(a)
+  }
+
+  trait YY extends XX {
+    type Foo = X & Y
+
+    def apply(fa: Bar[X & Foo]): Bar[Y & Foo] = fa
+  }
+  (new YY {}).boom // error
+                   // object creation impossible, since def apply(fa: String):
+                   // Int is not defined (Note that String does not match
+                   // Test3.Bar[X & Object with Test3.YY {...}#Foo])
+
+                   // So the apply in YY doesn't implements the one in XX, and
+                   // everything is nice and sound.
+}
+
+object Test4 {
+  type Bar[A] = A match {
+    case X => String
+    case Y => Int
+  }
+
+  trait XX {
+    type Foo
+    type FooAlias = Foo
+
+    val a: Bar[X & FooAlias] = "hello"
+    val b: Bar[Y & FooAlias] = 1
+
+    def apply(fa: Bar[X & FooAlias]): Bar[Y & FooAlias]
+
+    def boom: Int = apply(a)
+  }
+
+  trait YY extends XX {
+    type Foo = X & Y
+
+    def apply(fa: Bar[X & FooAlias]): Bar[Y & FooAlias] = fa
+  }
+  (new YY {}).boom // error
+                   // object creation impossible, since def apply(fa: String):
+                   // Int is not defined  (Note that String does not match
+                   // Test4.Bar[X & Object with Test4.YY {...}#FooAlias])
+}

tests/neg/6314.scala

@@ -46,53 +46,3 @@ object Test2 {
     def right(fa: Bar[L]): Int = fa // error
   }
 }
-
-
-object Test3 {
-  type Bar[A] = A match {
-    case X => String
-    case Y => Int
-  }
-
-  trait XX {
-    type Foo
-
-    val a: Bar[X & Foo] = "hello"
-    val b: Bar[Y & Foo] = 1 // error
-
-    def apply(fa: Bar[X & Foo]): Bar[Y & Foo]
-
-    def boom: Int = apply(a) // error
-  }
-
-  trait YY extends XX {
-    type Foo = X & Y
-
-    def apply(fa: Bar[X & Foo]): Bar[Y & Foo] = fa
-  }
-}
-
-object Test4 {
-  type Bar[A] = A match {
-    case X => String
-    case Y => Int
-  }
-
-  trait XX {
-    type Foo
-    type FooAlias = Foo
-
-    val a: Bar[X & FooAlias] = "hello"
-    val b: Bar[Y & FooAlias] = 1 // error
-
-    def apply(fa: Bar[X & FooAlias]): Bar[Y & FooAlias]
-
-    def boom: Int = apply(a) // error
-  }
-
-  trait YY extends XX {
-    type Foo = X & Y
-
-    def apply(fa: Bar[X & FooAlias]): Bar[Y & FooAlias] = fa
-  }
-}