document signature and add product pattern test

Author: liufengyun

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -377,8 +377,9 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
   /* Whether the extractor is irrefutable */
   def irrefutable(unapp: tpd.Tree): Boolean = {
     // TODO: optionless patmat
-    unapp.tpe.widen.resultType.isRef(scalaSomeClass) ||
-      (unapp.symbol.is(Synthetic) && unapp.symbol.owner.linkedClass.is(Case))
+    unapp.tpe.widen.finalResultType.isRef(scalaSomeClass) ||
+      (unapp.symbol.is(Synthetic) && unapp.symbol.owner.linkedClass.is(Case)) ||
+      productArity(unapp.tpe.widen.finalResultType) > 0
   }
 
   /** Return the space that represents the pattern `pat`
@@ -457,21 +458,31 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     def isSyntheticScala2Unapply(sym: Symbol) =
       sym.is(SyntheticCase) && sym.owner.is(Scala2x)
 
-    val mt@MethodType(_) = unapp.widen
+    val mt @ MethodType(_) = unapp.widen
+
+    // Case unapply:
+    // 1. return types of constructor fields if the extractor is synthesized for Scala2 case classes & length match
+    // 2. return Nil if unapply returns Boolean  (boolean pattern)
+    // 3. return product selector types if unapply returns a product type (product pattern)
+    // 4. return product selectors of `T` where `def get: T` is a member of the return type of unapply & length match (named-based pattern)
+    // 5. otherwise, return `T` where `def get: T` is a member of the return type of unapply
+    //
+    // Case unapplySeq:
+    // 1. return the type `List[T]` where `T` is the element type of the unapplySeq return type `Seq[T]`
 
     val sig =
       if (isSyntheticScala2Unapply(unappSym) && caseAccessors.length == argLen)
         caseAccessors.map(_.info.asSeenFrom(mt.paramInfos.head, caseClass).widen)
-      else if (mt.resultType.isRef(defn.BooleanClass))
+      else if (mt.finalResultType.isRef(defn.BooleanClass))
         List()
       else {
         val isUnapplySeq = unappSym.name == nme.unapplySeq
-        if (isProductMatch(mt.resultType, argLen) && !isUnapplySeq) {
-          productSelectors(mt.resultType).take(argLen)
-            .map(_.info.asSeenFrom(mt.resultType, mt.resultType.classSymbol).widen)
+        if (isProductMatch(mt.finalResultType, argLen) && !isUnapplySeq) {
+          productSelectors(mt.finalResultType).take(argLen)
+            .map(_.info.asSeenFrom(mt.finalResultType, mt.resultType.classSymbol).widen)
         }
         else {
-          val resTp = mt.resultType.select(nme.get).resultType.widen
+          val resTp = mt.finalResultType.select(nme.get).finalResultType.widen
           if (isUnapplySeq) scalaListType.appliedTo(resTp.argTypes.head) :: Nil
           else if (argLen == 0) Nil
           else if (isProductMatch(resTp, argLen))

tests/patmat/optionless.check

@@ -1,3 +1 @@
-20: Pattern Match Exhaustivity: _: Tree
-24: Pattern Match Exhaustivity: _: Tree
 28: Pattern Match Exhaustivity: _: Tree

tests/patmat/t10502.check

@@ -1,4 +1,4 @@
 5: Pattern Match Exhaustivity: Perhaps(None)
 15: Pattern Match Exhaustivity: Nil
 31: Pattern Match Exhaustivity: Multi(None, _)
-
+44: Pattern Match Exhaustivity: Prod(None, _)

tests/patmat/t10502.scala

@@ -32,3 +32,16 @@ object Multi {
      case Multi(Some(i), x) =>
   }
 }
+
+object Prod {
+  def unapply(str: String): (Option[Int], Int) = ???
+
+  "hello" match {
+     case Prod(Some(i), x) =>
+     case Prod(None, x) =>
+  }
+
+  "hello" match {
+     case Prod(Some(i), x) =>
+  }
+}