Fix #6490: Add spec for irrefutable extractors

Author: liufengyun

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -715,7 +715,8 @@ object desugar {
           val methName = if (hasRepeatedParam) nme.unapplySeq else nme.unapply
           val unapplyParam = makeSyntheticParameter(tpt = classTypeRef)
           val unapplyRHS = if (arity == 0) Literal(Constant(true)) else Ident(unapplyParam.name)
-          DefDef(methName, derivedTparams, (unapplyParam :: Nil) :: Nil, TypeTree(), unapplyRHS)
+          val unapplyResTp = if (arity == 0) Literal(Constant(true)) else TypeTree()
+          DefDef(methName, derivedTparams, (unapplyParam :: Nil) :: Nil, unapplyResTp, unapplyRHS)
             .withMods(synthetic)
         }
         companionDefs(companionParent, applyMeths ::: unapplyMeth :: companionMembers)

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

@@ -275,12 +275,15 @@ object SpaceEngine {
   /** Is the unapply irrefutable?
    *  @param  unapp   The unapply function reference
    */
-  def isIrrefutableUnapply(unapp: tpd.Tree)(implicit ctx: Context): Boolean = {
+  def isIrrefutableUnapply(unapp: tpd.Tree, patSize: Int)(implicit ctx: Context): Boolean = {
     val unappResult = unapp.tpe.widen.finalResultType
     unappResult.isRef(defn.SomeClass) ||
-    unappResult =:= ConstantType(Constant(true)) ||
-    (unapp.symbol.is(Synthetic) && unapp.symbol.owner.linkedClass.is(Case)) ||
-    productArity(unappResult) > 0
+    unappResult <:< ConstantType(Constant(true)) ||
+    (unapp.symbol.is(Synthetic) && unapp.symbol.owner.linkedClass.is(Case)) ||  // scala2 compatibility
+    (patSize != -1 && productArity(unappResult) == patSize) || {
+      val isEmptyTp = extractorMemberType(unappResult, nme.isEmpty, unapp.sourcePos)
+      isEmptyTp <:< ConstantType(Constant(true))
+    }
   }
 }
 
@@ -348,16 +351,15 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
         else {
           val (arity, elemTp, resultTp) = unapplySeqInfo(fun.tpe.widen.finalResultType, fun.sourcePos)
           if (elemTp.exists)
-            Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, projectSeq(pats) :: Nil, isIrrefutableUnapply(fun))
+            Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, projectSeq(pats) :: Nil, isIrrefutableUnapply(fun, -1))
           else
-            Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, pats.take(arity - 1).map(project) :+ projectSeq(pats.drop(arity - 1)),isIrrefutableUnapply(fun))
+            Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, pats.take(arity - 1).map(project) :+ projectSeq(pats.drop(arity - 1)), full = true)
         }
       else
-        Prod(erase(pat.tpe.stripAnnots), erase(fun.tpe), fun.symbol, pats.map(project), isIrrefutableUnapply(fun))
-    case Typed(expr @ Ident(nme.WILDCARD), tpt) =>
+        Prod(erase(pat.tpe.stripAnnots), erase(fun.tpe), fun.symbol, pats.map(project), isIrrefutableUnapply(fun, pats.length))
+    case Typed(pat @ UnApply(_, _, _), _) => project(pat)
+    case Typed(expr, _) =>
       Typ(erase(expr.tpe.stripAnnots), true)
-    case Typed(pat, _) =>
-      project(pat)
     case This(_) =>
       Typ(pat.tpe.stripAnnots, false)
     case EmptyTree =>         // default rethrow clause of try/catch, check tests/patmat/try2.scala

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

@@ -71,7 +71,7 @@ object Applications {
    *  parameterless `isEmpty` member of result type `Boolean`.
    */
   def isGetMatch(tp: Type, errorPos: SourcePosition = NoSourcePosition)(implicit ctx: Context): Boolean =
-    extractorMemberType(tp, nme.isEmpty, errorPos).isRef(defn.BooleanClass) &&
+    extractorMemberType(tp, nme.isEmpty, errorPos).widenSingleton.isRef(defn.BooleanClass) &&
     extractorMemberType(tp, nme.get, errorPos).exists
 
   /** If `getType` is of the form:

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

@@ -644,7 +644,7 @@ trait Checking {
             recur(pat1, pt)
           case UnApply(fn, _, pats) =>
             check(pat, pt) &&
-            (isIrrefutableUnapply(fn) || fail(pat, pt)) && {
+            (isIrrefutableUnapply(fn, pats.length) || fail(pat, pt)) && {
               val argPts = unapplyArgs(fn.tpe.widen.finalResultType, fn, pats, pat.sourcePos)
               pats.corresponds(argPts)(recur)
             }

docs/docs/reference/changed-features/pattern-matching.md

@@ -50,6 +50,13 @@ and `S` conforms to one of the following matches:
 The former form of `unapply` has higher precedence, and _single match_ has higher
 precedence over _name-based match_.
 
+A usage of a fixed-arity extractor is irrefutable if one of the following condition holds:
+
+- `U = true`
+- the extractor is used as a product match
+- `U = Some[T]` (for Scala2 compatibility)
+- `U <: R` and `U <: { def isEmpty: true }`
+
 ### Variadic Extractors
 
 Variadic extractors expose the following signature:
@@ -77,6 +84,12 @@ and `S` conforms to one of the two matches above.
 The former form of `unapplySeq` has higher priority, and _sequence match_ has higher
 precedence over _product-sequence match_.
 
+A usage of a variadic extractor is irrefutable if one of the following condition holds:
+
+- the extractor is used directly as a sequence match or product-sequence match
+- `U = Some[T]` (for Scala2 compatibility)
+- `U <: R` and `U <: { def isEmpty: true }`
+
 ## Boolean Match
 
 - `U =:= Boolean`

tests/patmat/irrefutable.check

@@ -0,0 +1,2 @@
+22: Pattern Match Exhaustivity: _: Base
+65: Pattern Match Exhaustivity: _: M

tests/patmat/irrefutable.scala

@@ -0,0 +1,85 @@
+sealed trait Base
+sealed class A(s: String) extends Base
+sealed class B(val n: Int) extends Base
+sealed case class C(val s: String, val n: Int) extends Base
+
+// boolean
+object ExTrue {
+  def unapply(b: Base): true = b match {
+    case _ => true
+  }
+
+  def test(b: Base) = b match {
+    case ExTrue() =>
+  }
+}
+
+object ExFalse {
+  def unapply(b: Base): Boolean = b match {
+    case _ => true
+  }
+
+  def test(b: Base) = b match {  // warning
+    case ExFalse() =>
+  }
+}
+
+// product
+
+object ExProduct {
+  def unapply(b: B): (Int, Int) = (b.n, b.n * b.n)
+  def test(b: B) = b match {
+    case ExProduct(x, xx) =>
+  }
+}
+
+// isEmpty/get
+
+trait Res {
+  def isEmpty: true = true
+  def get: Int
+}
+
+object ExName {
+  def unapply(b: B): Res = new Res { def get: Int = b.n }
+
+  def test(b: B) = b match {
+    case ExName(x) =>
+  }
+}
+
+sealed class M(n: Int, s: String) extends Product {
+  def _1: Int = n
+  def _2: String = s
+  def isEmpty: Boolean = s.size > n
+  def get: M = this
+
+  def canEqual(that: Any): Boolean = true
+  def productArity: Int = 2
+  def productElement(n: Int): Any = ???
+}
+
+object ExM {
+  def unapply(m: M): M = m
+
+  def test(m: M) = m match {  // warning
+    case ExM(s) =>
+  }
+}
+
+// some
+object ExSome {
+  def unapply(b: B): Some[Int] = Some(b.n)
+
+  def test(b: B) = b match {
+    case ExSome(x) =>
+  }
+}
+
+object ExSome2 {
+  def unapply(c: C): Some[C] = Some(c)
+
+  def test(c: C) = c match {
+    case ExSome2(s, n) =>
+  }
+}