Fix exhaustivity check

Author: liufengyun

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

@@ -335,13 +335,25 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     case Bind(_, pat) => project(pat)
     case SeqLiteral(pats, _) => projectSeq(pats)
     case UnApply(fun, _, pats) =>
-      if (fun.symbol.name == nme.unapplySeq)
-        if (fun.symbol.owner == scalaSeqFactoryClass)
-          projectSeq(pats)
-        else
+      if (fun.symbol.owner == scalaSeqFactoryClass && fun.symbol.name == nme.unapplySeq)
+        projectSeq(pats)
+      else {
+        var tp = fun.tpe.widen.finalResultType
+        var arity = productArity(tp, fun.sourcePos)
+        if (arity <= 0) {
+          tp = fun.tpe.widen.finalResultType.select(nme.get).finalResultType.widen
+          if (pats.length == 1)
+            return Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, pats.map(project), irrefutable(fun))
+          arity = productSelectorTypes(tp, fun.sourcePos).size
+        }
+
+        if (arity > 0 && arity != pats.length)
+          Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, pats.take(arity - 1).map(project) :+ projectSeq(pats.drop(arity - 1)), irrefutable(fun))
+        else if (arity <= 0 && unapplySeqTypeElemTp(tp).exists)
           Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, projectSeq(pats) :: Nil, irrefutable(fun))
-      else
-        Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, pats.map(project), irrefutable(fun))
+        else
+          Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, pats.map(project), irrefutable(fun))
+      }
     case Typed(pat @ UnApply(_, _, _), _) => project(pat)
     case Typed(expr, tpt) =>
       Typ(erase(expr.tpe.stripAnnots), true)
@@ -424,17 +436,27 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
         List()
       else {
         val isUnapplySeq = unappSym.name == nme.unapplySeq
-        if (productArity(mt.finalResultType, unappSym.sourcePos) > 0 && !isUnapplySeq) {
-          productSelectors(mt.finalResultType).take(argLen)
-            .map(_.info.asSeenFrom(mt.finalResultType, mt.resultType.classSymbol).widenExpr)
+        val arity = productArity(mt.finalResultType, unappSym.sourcePos)
+        if (arity > 0 && !isUnapplySeq) {
+          if (arity != argLen) {
+            val sels = productSeqSelectors(mt.finalResultType, arity, unappSym.sourcePos)
+            sels.init :+ scalaListType.appliedTo(sels.last)
+          }
+          else
+            productSelectors(mt.finalResultType)
+              .map(_.info.asSeenFrom(mt.finalResultType, mt.resultType.classSymbol).widenExpr)
         }
         else {
           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))
+          val arity = productArity(resTp, unappSym.sourcePos)
+          if (isUnapplySeq && arity < 0) scalaListType.appliedTo(resTp.argTypes.head) :: Nil
+          else if (argLen == 1) resTp :: Nil
+          else if (arity > 0 && arity != argLen) {
+            val sels = productSeqSelectors(resTp, arity, unappSym.sourcePos)
+            sels.init :+ scalaListType.appliedTo(sels.last)
+          }
+          else
             productSelectors(resTp).map(_.info.asSeenFrom(resTp, resTp.classSymbol).widenExpr)
-          else resTp :: Nil
         }
       }
 

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

@@ -133,15 +133,15 @@ object Applications {
     if (args.length > 1 && !(tp.derivesFrom(defn.SeqClass))) {
       val sels = productSelectorTypes(tp, pos)
       if (sels.length == args.length) sels
-      else if (isProductSeqMatch(tp, args.length, pos)) productSeqSelectors(tp, args, pos)
+      else if (isProductSeqMatch(tp, args.length, pos)) productSeqSelectors(tp, args.length, pos)
       else tp :: Nil
     } else tp :: Nil
 
-  def productSeqSelectors(tp: Type, args: List[untpd.Tree], pos: SourcePosition)(implicit ctx: Context): List[Type] = {
+  def productSeqSelectors(tp: Type, argsNum: Int, pos: SourcePosition)(implicit ctx: Context): List[Type] = {
       val selTps = productSelectorTypes(tp, pos)
       val arity = selTps.length
       val elemTp = unapplySeqTypeElemTp(selTps.last)
-      (0 until args.length).map(i => if (i < arity - 1) selTps(i) else elemTp).toList
+      (0 until argsNum).map(i => if (i < arity - 1) selTps(i) else elemTp).toList
     }
 
   def unapplyArgs(unapplyResult: Type, unapplyFn: Tree, args: List[untpd.Tree], pos: SourcePosition)(implicit ctx: Context): List[Type] = {
@@ -159,7 +159,7 @@ object Applications {
       if (isGetMatch(unapplyResult, pos)) {
         val elemTp = unapplySeqTypeElemTp(getTp)
         if (elemTp.exists) args.map(Function.const(elemTp))
-        else if (isProductSeqMatch(getTp, args.length, pos)) productSeqSelectors(getTp, args, pos)
+        else if (isProductSeqMatch(getTp, args.length, pos)) productSeqSelectors(getTp, args.length, pos)
         else fail
       }
       else fail
@@ -169,7 +169,7 @@ object Applications {
       if (isProductMatch(unapplyResult, args.length, pos))
         productSelectorTypes(unapplyResult, pos)
       else if (isProductSeqMatch(unapplyResult, args.length, pos))
-        productSeqSelectors(unapplyResult, args, pos)
+        productSeqSelectors(unapplyResult, args.length, pos)
       else if (isGetMatch(unapplyResult, pos))
         getUnapplySelectors(getTp, args, pos)
       else if (unapplyResult.widenSingleton isRef defn.BooleanClass)