Eliminate Config.newMatch option

With the new approach to matching it is no longer sound.
We always have to match infos anyway to be sure.

Author: odersky

src/dotty/tools/dotc/config/Config.scala

@@ -71,12 +71,6 @@ object Config {
   /** If this flag is set, take the fast path when comparing same-named type-aliases and types */
   final val fastPathForRefinedSubtype = true
 
-  /** When set, use new signature-based matching.
-   *  Advantage of doing so: It's supposed to be faster
-   *  Disadvantage: It might hide inconsistencies, so while debugging it's better to turn it off
-   */
-  final val newMatch = false
-
   /** The recursion depth for showing a summarized string */
   final val summarizeDepth = 2
 

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

@@ -358,8 +358,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       def compareMethod = tp1 match {
         case tp1 @ MethodType(_, formals1) =>
           (tp1.signature sameParams tp2.signature) &&
-            (if (Config.newMatch) subsumeParams(formals1, formals2, tp1.isJava, tp2.isJava)
-            else matchingParams(formals1, formals2, tp1.isJava, tp2.isJava)) &&
+            matchingParams(formals1, formals2, tp1.isJava, tp2.isJava) &&
             tp1.isImplicit == tp2.isImplicit && // needed?
             isSubType(tp1.resultType, tp2.resultType.subst(tp2, tp1))
         case _ =>
@@ -708,21 +707,6 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       formals2.isEmpty
   }
 
-  private def subsumeParams(formals1: List[Type], formals2: List[Type], isJava1: Boolean, isJava2: Boolean): Boolean = formals1 match {
-    case formal1 :: rest1 =>
-      formals2 match {
-        case formal2 :: rest2 =>
-          (isSubType(formal2, formal1)
-            || isJava1 && (formal2 isRef ObjectClass) && (formal1 isRef AnyClass)
-            || isJava2 && (formal1 isRef ObjectClass) && (formal2 isRef AnyClass)) &&
-          subsumeParams(rest1, rest2, isJava1, isJava2)
-        case nil =>
-          false
-      }
-    case nil =>
-      formals2.isEmpty
-  }
-
   /** Do poly types `poly1` and `poly2` have type parameters that
    *  have the same bounds (after renaming one set to the other)?
    */
@@ -951,13 +935,6 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     case tp1 @ MethodType(names1, formals1) =>
       tp2 match {
         case tp2 @ MethodType(names2, formals2)
-        if Config.newMatch && tp1.signature.sameParams(tp2.signature) &&
-           tp1.isImplicit == tp2.isImplicit =>
-          tp1.derivedMethodType(
-              mergeNames(names1, names2, nme.syntheticParamName),
-              (formals1 zipWithConserve formals2)(_ | _),
-              tp1.resultType & tp2.resultType.subst(tp2, tp1))
-        case tp2 @ MethodType(names2, formals2)
         if matchingParams(formals1, formals2, tp1.isJava, tp2.isJava) &&
            tp1.isImplicit == tp2.isImplicit =>
           tp1.derivedMethodType(
@@ -1017,13 +994,6 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     case tp1 @ MethodType(names1, formals1) =>
       tp2 match {
         case tp2 @ MethodType(names2, formals2)
-        if Config.newMatch && tp1.signature.sameParams(tp2.signature) &&
-           tp1.isImplicit == tp2.isImplicit =>
-          tp1.derivedMethodType(
-              mergeNames(names1, names2, nme.syntheticParamName),
-              (formals1 zipWithConserve formals2)(_ & _),
-              tp1.resultType | tp2.resultType.subst(tp2, tp1))
-        case tp2 @ MethodType(names2, formals2)
         if matchingParams(formals1, formals2, tp1.isJava, tp2.isJava) &&
            tp1.isImplicit == tp2.isImplicit =>
           tp1.derivedMethodType(

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

@@ -647,12 +647,9 @@ object Types {
      *  (*) when matching with a Java method, we also regard Any and Object as equivalent
      *      parameter types.
      */
-    def matches(that: Type)(implicit ctx: Context): Boolean =
-      if (Config.newMatch) this.signature matches that.signature
-      else track("matches") {
-        ctx.typeComparer.matchesType(
-          this, that, relaxed = !ctx.phase.erasedTypes)
-      }
+    def matches(that: Type)(implicit ctx: Context): Boolean = track("matches") {
+      ctx.typeComparer.matchesType(this, that, relaxed = !ctx.phase.erasedTypes)
+    }
 
     /** This is the same as `matches` except that it also matches => T with T and
      *  vice versa.