Revert name change on isProductMatch & isProductSubType

Author: OlivierBlanvillain

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

@@ -840,7 +840,7 @@ class Definitions {
     TupleType(elems.size).appliedTo(elems)
   }
 
-  def isNameBasedPatternSubType(tp: Type)(implicit ctx: Context) =
+  def isProductSubType(tp: Type)(implicit ctx: Context) =
     tp.derivesFrom(ProductType.symbol)
 
   /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ImplicitFunctionN? */

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

@@ -234,7 +234,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 (isProductMatch(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 (isNameBasedMatch(resultType, aligner.prodArity)) resultType
+        else if (isProductMatch(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.isNameBasedPatternSubType(binder.info))
+          if (defn.isProductSubType(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) &&
-                 !isNameBasedMatch(binderTypeTested, aligner.prodArity) && isGetMatch(binderTypeTested))
+                 !isProductMatch(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.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)
+          if (isProductMatch(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

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