Remove NameBasedPattern, use scala.Product instead

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -414,10 +414,10 @@ object desugar {
       if (arity > Definitions.MaxTupleArity) scalaDot(nme.Product.toTypeName)
       else productConstr(arity)
 
-    // Case classes and case objects get NameBasedPattern and Product/ProductN parents
+    // Case classes and case objects get Product/ProductN parents
     val parents1: List[Tree] =
       if (mods.is(Case))
-        parents :+ product :+ scalaDot(nme.NameBasedPattern.toTypeName)
+        parents :+ product
       else parents
 
     // The thicket which is the desugared version of the companion object

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

@@ -513,7 +513,6 @@ class Definitions {
   def DynamicClass(implicit ctx: Context) = DynamicType.symbol.asClass
   lazy val OptionType: TypeRef                  = ctx.requiredClassRef("scala.Option")
   def OptionClass(implicit ctx: Context) = OptionType.symbol.asClass
-  lazy val NameBasedPatternType: TypeRef        = ctx.requiredClassRef("scala.NameBasedPattern")
   lazy val ProductType: TypeRef                 = ctx.requiredClassRef("scala.Product")
   def ProductClass(implicit ctx: Context) = ProductType.symbol.asClass
     lazy val Product_canEqualR = ProductClass.requiredMethodRef(nme.canEqual_)
@@ -841,15 +840,8 @@ class Definitions {
     TupleType(elems.size).appliedTo(elems)
   }
 
-  /** Is this type eligible for name based pattern matching?
-   *
-   *  That means either extending `scala.ProductN` OR `NameBasedPattern`.
-   *  In the long term, we can remove the first condition by having
-   *  `scala.ProductN` inherit `NameBasedPattern`.
-   */
   def isNameBasedPatternSubType(tp: Type)(implicit ctx: Context) =
-    (tp.derivesFrom(ProductType.symbol) && tp.baseClasses.exists(isProductClass)) ||
-    tp.derivesFrom(NameBasedPatternType.symbol)
+    tp.derivesFrom(ProductType.symbol)
 
   /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ImplicitFunctionN? */
   def isFunctionType(tp: Type)(implicit ctx: Context) = {

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

@@ -186,7 +186,6 @@ object StdNames {
     final val Function: N            = "Function"
     final val ImplicitFunction: N    = "ImplicitFunction"
     final val Mirror: N              = "Mirror"
-    final val NameBasedPattern: N    = "NameBasedPattern"
     final val Nothing: N             = "Nothing"
     final val Null: N                = "Null"
     final val Object: N              = "Object"

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

@@ -51,11 +51,11 @@ object Applications {
    *  type  for a pattern with `numArgs` subpatterns.
    *
    *  This is the case if:
-   *    - `tp` is a subtype of the Product<numArgs> class or `NameBasedPattern` trait
+   *    - `tp` is a subtype of the Product trait
    *    - `tp` has members `_1` to `_N` where `N == numArgs`
    */
-  def isNameBasedMatch(tp: Type, numArgs: Int)(implicit ctx: Context) =
-    0 <= numArgs && defn.isNameBasedPatternSubType(tp) &&
+  def isProductMatch(tp: Type, numArgs: Int)(implicit ctx: Context) =
+    numArgs > 0 && defn.isProductSubType(tp) &&
     productSelectorTypes(tp).size == numArgs
 
   /** Does `tp` fit the "get match" conditions as an unapply result type?