Rename *product* methods and update scaladoc

Author: OlivierBlanvillain

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

@@ -841,14 +841,17 @@ class Definitions {
     TupleType(elems.size).appliedTo(elems)
   }
 
-  def isProductSubType(tp: Type)(implicit ctx: Context) =
+  /** Is this type eligible for name based pattern matching?
+   *
+   *  That means either extending `scala.ProductN` or `NameBasedPattern`.
+   *  Ideally only the second condition should be used, first on is kept
+   *  for compatibility with scala2 compiled case classes.
+   */
+  def isNameBasedPatternSubType(tp: Type)(implicit ctx: Context) =
     (tp.derivesFrom(ProductType.symbol) && tp.baseClasses.exists(isProductClass)) ||
     tp.derivesFrom(NameBasedPatternType.symbol)
 
-  def productArity(tp: Type)(implicit ctx: Context) =
-    if (isProductSubType(tp)) typer.Applications.productSelectorTypes(tp).size else -1
-
-  /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ImplicitFunctionN ? */
+  /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ImplicitFunctionN? */
   def isFunctionType(tp: Type)(implicit ctx: Context) = {
     val arity = functionArity(tp)
     val sym = tp.dealias.typeSymbol

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -233,8 +233,8 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
         // next: MatchMonad[U]
         // returns MatchMonad[U]
         def flatMap(prev: Tree, b: Symbol, next: Tree): Tree = {
-          val resultArity = defn.productArity(b.info)
-          if (isProductMatch(prev.tpe, resultArity)) {
+          val resultArity = productArity(b.info)
+          if (isNameBasedMatch(prev.tpe, resultArity)) {
             val nullCheck: Tree = prev.select(defn.Object_ne).appliedTo(Literal(Constant(null)))
             ifThenElseZero(
               nullCheck,
@@ -1426,7 +1426,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
 
       def resultInMonad  =
         if (aligner.isBool) defn.UnitType
-        else if (isProductMatch(resultType, aligner.prodArity)) resultType
+        else if (isNameBasedMatch(resultType, aligner.prodArity)) resultType
         else if (isGetMatch(resultType)) extractorMemberType(resultType, nme.get)
         else resultType
 
@@ -1470,7 +1470,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.isProductSubType(binder.info))
+          if (defn.isNameBasedPatternSubType(binder.info))
             productSelectors(binder.info)
           else binder.caseAccessors
         val res =
@@ -1627,7 +1627,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
           ref(binder) :: Nil
         }
         else if ((aligner.isSingle && aligner.extractor.prodArity == 1) &&
-                 !isProductMatch(binderTypeTested, aligner.prodArity) && isGetMatch(binderTypeTested))
+                 !isNameBasedMatch(binderTypeTested, aligner.prodArity) && isGetMatch(binderTypeTested))
           List(ref(binder))
         else
           subPatRefs(binder)
@@ -1878,11 +1878,11 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
 
         val expanded: List[Type] = /*(
           if (result =:= defn.BooleanType) Nil
-          else if (defn.isProductSubType(result)) productSelectorTypes(result)
+          else if (defn.isNameBasedPatternSubType(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 (isProductMatch(resultType, args.length)) productSelectorTypes(resultType)
+          if (isNameBasedMatch(resultType, args.length)) productSelectorTypes(resultType)
           else if (isGetMatch(resultType)) getUnapplySelectors(resultOfGet, args)
           else if (resultType isRef defn.BooleanClass) Nil
           else {

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

@@ -47,12 +47,15 @@ object Applications {
     ref.info.widenExpr.dealias
   }
 
-  /** Does `tp` fit the "product match" conditions as an unapply result type
-   *  for a pattern with `numArgs` subpatterns>
-   *  This is the case of `tp` is a subtype of the Product<numArgs> class.
+  /** Does `tp` fit the "name based pattern match" conditions as an unapply result
+   *  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` has members `_1` to `_N` where `N == numArgs`
    */
-  def isProductMatch(tp: Type, numArgs: Int)(implicit ctx: Context) =
-    0 <= numArgs && defn.isProductSubType(tp) &&
+  def isNameBasedMatch(tp: Type, numArgs: Int)(implicit ctx: Context) =
+    0 <= numArgs && defn.isNameBasedPatternSubType(tp) &&
     productSelectorTypes(tp).size == numArgs
 
   /** Does `tp` fit the "get match" conditions as an unapply result type?
@@ -68,6 +71,9 @@ object Applications {
     sels.takeWhile(_.exists).toList
   }
 
+  def productArity(tp: Type)(implicit ctx: Context) =
+    if (defn.isNameBasedPatternSubType(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
     sels.takeWhile(_.exists).toList
@@ -102,13 +108,13 @@ object Applications {
     }
     else {
       assert(unapplyName == nme.unapply)
-      if (isProductMatch(unapplyResult, args.length))
+      if (isNameBasedMatch(unapplyResult, args.length))
         productSelectorTypes(unapplyResult)
       else if (isGetMatch(unapplyResult, pos))
         getUnapplySelectors(getTp, args, pos)
       else if (unapplyResult isRef defn.BooleanClass)
         Nil
-      else if (defn.isProductSubType(unapplyResult))
+      else if (defn.isNameBasedPatternSubType(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/Typer.scala

@@ -762,7 +762,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.isProductSubType(formal)                &&
+        defn.isNameBasedPatternSubType(formal)       &&
         Applications.productSelectorTypes(formal).corresponds(params) {
           (argType, param) =>
             param.tpt.isEmpty || argType <:< typedAheadType(param.tpt).tpe