Remove NameBasedPattern, use scala.Product instead

Author: OlivierBlanvillain

compiler/foo

@@ -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/ast/Desugar.scala

@@ -508,7 +508,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_)
@@ -794,15 +793,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)
+  def isProductSubType(tp: Type)(implicit ctx: Context) =
+    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/Definitions.scala

@@ -184,7 +184,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/core/StdNames.scala

@@ -236,7 +236,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
         // returns MatchMonad[U]
         def flatMap(prev: Tree, b: Symbol, next: Tree): Tree = {
           val resultArity = productArity(b.info)
-          if (isNameBasedMatch(prev.tpe, resultArity)) {
+          if (!isGetMatch(prev.tpe)) {
             val nullCheck: Tree = prev.select(defn.Object_ne).appliedTo(Literal(Constant(null)))
             ifThenElseZero(
               nullCheck,
@@ -1430,8 +1430,8 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
 
       def resultInMonad  =
         if (aligner.isBool) defn.UnitType
-        else if (isNameBasedMatch(resultType, aligner.prodArity)) resultType
         else if (isGetMatch(resultType)) extractorMemberType(resultType, nme.get)
+        else if (isProductMatch(resultType, aligner.prodArity)) resultType
         else resultType
 
       def resultType: Type
@@ -1474,7 +1474,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
       protected def seqTree(binder: Symbol)                = tupleSel(binder)(firstIndexingBinder + 1)
       protected def tupleSel(binder: Symbol)(i: Int): Tree = {
         val accessors =
-          if (defn.isNameBasedPatternSubType(binder.info))
+          if (defn.isProductSubType(binder.info))
             productSelectors(binder.info)
           else binder.caseAccessors
         val res =
@@ -1631,7 +1631,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
           ref(binder) :: Nil
         }
         else if ((aligner.isSingle && aligner.extractor.prodArity == 1) &&
-                 !isNameBasedMatch(binderTypeTested, aligner.prodArity) && isGetMatch(binderTypeTested))
+                 !isProductMatch(binderTypeTested, aligner.prodArity) && isGetMatch(binderTypeTested))
           List(ref(binder))
         else
           subPatRefs(binder)
@@ -1882,12 +1882,12 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
 
         val expanded: List[Type] = /*(
           if (result =:= defn.BooleanType) Nil
-          else if (defn.isNameBasedPatternSubType(result)) productSelectorTypes(result)
+          else if (defn.isProductSubType(result)) productSelectorTypes(result)
           else if (result.classSymbol is Flags.CaseClass) result.decls.filter(x => x.is(Flags.CaseAccessor) && x.is(Flags.Method)).map(_.info).toList
           else result.select(nme.get) :: Nil
           )*/
-          if (isNameBasedMatch(resultType, args.length)) productSelectorTypes(resultType)
-          else if (isGetMatch(resultType)) getUnapplySelectors(resultOfGet, args)
+          if (isGetMatch(resultType)) getUnapplySelectors(resultOfGet, args)
+          else if (isProductMatch(resultType, args.length)) productSelectorTypes(resultType)
           else if (resultType isRef defn.BooleanClass) Nil
           else {
             ctx.error(i"invalid return type in Unapply node: $resultType")

compiler/src/dotty/tools/dotc/transform/PatternMatcher.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) =
+    0 <= numArgs && defn.isProductSubType(tp) &&
     productSelectorTypes(tp).size == numArgs
 
   /** Does `tp` fit the "get match" conditions as an unapply result type?
@@ -72,7 +72,7 @@ object Applications {
   }
 
   def productArity(tp: Type)(implicit ctx: Context) =
-    if (defn.isNameBasedPatternSubType(tp)) productSelectorTypes(tp).size else -1
+    if (defn.isProductSubType(tp)) productSelectorTypes(tp).size else -1
 
   def productSelectors(tp: Type)(implicit ctx: Context): List[Symbol] = {
     val sels = for (n <- Iterator.from(0)) yield tp.member(nme.selectorName(n)).symbol
@@ -108,13 +108,13 @@ object Applications {
     }
     else {
       assert(unapplyName == nme.unapply)
-      if (isNameBasedMatch(unapplyResult, args.length))
+      if (isProductMatch(unapplyResult, args.length))
         productSelectorTypes(unapplyResult)
       else if (isGetMatch(unapplyResult, pos))
         getUnapplySelectors(getTp, args, pos)
       else if (unapplyResult isRef defn.BooleanClass)
         Nil
-      else if (defn.isNameBasedPatternSubType(unapplyResult))
+      else if (defn.isProductSubType(unapplyResult))
         productSelectorTypes(unapplyResult)
           // this will cause a "wrong number of arguments in pattern" error later on,
           // which is better than the message in `fail`.

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

@@ -747,7 +747,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       /** Is `formal` a product type which is elementwise compatible with `params`? */
       def ptIsCorrectProduct(formal: Type) = {
         isFullyDefined(formal, ForceDegree.noBottom) &&
-        defn.isNameBasedPatternSubType(formal)       &&
+        defn.isProductSubType(formal) &&
         Applications.productSelectorTypes(formal).corresponds(params) {
           (argType, param) =>
             param.tpt.isEmpty || argType <:< typedAheadType(param.tpt).tpe

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

@@ -0,0 +1,27 @@
+// Tricky case (exercised by Scala parser combinators) where we use
+// both get/isEmpty and product-based pattern matching in different
+// matches on the same types.
+object ProductAndGet {
+
+  trait Result[+T]
+  case class Success[+T](in: String, x: T) extends Result[T] {
+    def isEmpty = false
+    def get: T = x
+  }
+  case class Failure[+T](in: String, msg: String) extends Result[T] {
+    def isEmpty = false
+    def get: String = msg
+  }
+
+  val r: Result[Int] = ???
+
+  r match {
+    case Success(in, x) => x // error
+    case Failure(in, msg) => -1 // error
+  }
+
+  r match {
+    case Success(x) => x
+    case Failure(msg) => -1
+  }
+}

library/src/scala/NameBasedPattern.scala

@@ -108,31 +108,3 @@ object NestedPattern {
   val xss: List[List[String]] = ???
   val List(List(x)) = xss
 }
-
-// Tricky case (exercised by Scala parser combinators) where we use
-// both get/isEmpty and product-based pattern matching in different
-// matches on the same types.
-object ProductAndGet {
-
-  trait Result[+T]
-  case class Success[+T](in: String, x: T) extends Result[T] {
-    def isEmpty = false
-    def get: T = x
-  }
-  case class Failure[+T](in: String, msg: String) extends Result[T] {
-    def isEmpty = false
-    def get: String = msg
-  }
-
-  val r: Result[Int] = ???
-
-  r match {
-    case Success(in, x) => x
-    case Failure(in, msg) => -1
-  }
-
-  r match {
-    case Success(x) => x
-    case Failure(msg) => -1
-  }
-}