Fix treatment of UnApply pattern definitions

Author: odersky

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

@@ -280,11 +280,25 @@ trait SpaceLogic {
   }
 }
 
+object SpaceEngine {
+
+  /** Is the unapply irrefutable?
+   *  @param  unapp   The unapply function reference
+   */
+  def isIrrefutableUnapply(unapp: tpd.Tree)(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
+  }
+}
+
 /** Scala implementation of space logic */
 class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
   import tpd._
+  import SpaceEngine._
 
-  private val scalaSomeClass       = ctx.requiredClass("scala.Some")
   private val scalaSeqFactoryClass = ctx.requiredClass("scala.collection.generic.SeqFactory")
   private val scalaListType        = ctx.requiredClassRef("scala.collection.immutable.List")
   private val scalaNilType         = ctx.requiredModuleRef("scala.collection.immutable.Nil")
@@ -309,15 +323,6 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     else Typ(AndType(tp1, tp2), true)
   }
 
-  /** Whether the extractor is irrefutable */
-  def irrefutable(unapp: Tree): Boolean = {
-    // TODO: optionless patmat
-    unapp.tpe.widen.finalResultType.isRef(scalaSomeClass) ||
-      unapp.tpe.widen.finalResultType =:= ConstantType(Constant(true)) ||
-      (unapp.symbol.is(Synthetic) && unapp.symbol.owner.linkedClass.is(Case)) ||
-      productArity(unapp.tpe.widen.finalResultType) > 0
-  }
-
   /** Return the space that represents the pattern `pat` */
   def project(pat: Tree): Space = pat match {
     case Literal(c) =>
@@ -340,12 +345,12 @@ 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, irrefutable(fun))
+            Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, projectSeq(pats) :: Nil, isIrrefutableUnapply(fun))
           else
-            Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, pats.take(arity - 1).map(project) :+ projectSeq(pats.drop(arity - 1)), irrefutable(fun))
+            Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, pats.take(arity - 1).map(project) :+ projectSeq(pats.drop(arity - 1)),isIrrefutableUnapply(fun))
         }
       else
-        Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, pats.map(project), irrefutable(fun))
+        Prod(erase(pat.tpe.stripAnnots), fun.tpe, fun.symbol, pats.map(project), isIrrefutableUnapply(fun))
     case Typed(pat @ UnApply(_, _, _), _) => project(pat)
     case Typed(expr, tpt) =>
       Typ(erase(expr.tpe.stripAnnots), true)

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

@@ -26,6 +26,7 @@ import ErrorReporting.{err, errorType}
 import config.Printers.{typr, patmatch}
 import NameKinds.DefaultGetterName
 import Applications.unapplyArgs
+import transform.patmat.SpaceEngine.isIrrefutableUnapply
 
 import collection.mutable
 import SymDenotations.{NoCompleter, NoDenotation}
@@ -604,27 +605,26 @@ trait Checking {
   def checkIrrefutable(pat: Tree, pt: Type)(implicit ctx: Context): Boolean = {
     patmatch.println(i"check irrefutable $pat: ${pat.tpe} against $pt")
 
-    def check(pat: Tree, pt: Type): Boolean = {
-      if (pt <:< pat.tpe)
-        true
-      else {
-        ctx.errorOrMigrationWarning(
-          ex"""pattern's type ${pat.tpe} is more specialized than the right hand side expression's type ${pt.dropAnnot(defn.UncheckedAnnot)}
-              |
-              |If the narrowing is intentional, this can be communicated by writing `: @unchecked` after the full pattern.${err.rewriteNotice}""",
-          pat.sourcePos)
-        false
-      }
+    def fail(pat: Tree, pt: Type): Boolean = {
+      ctx.errorOrMigrationWarning(
+        ex"""pattern's type ${pat.tpe} is more specialized than the right hand side expression's type ${pt.dropAnnot(defn.UncheckedAnnot)}
+            |
+            |If the narrowing is intentional, this can be communicated by writing `: @unchecked` after the full pattern.${err.rewriteNotice}""",
+        pat.sourcePos)
+      false
     }
 
+    def check(pat: Tree, pt: Type): Boolean = (pt <:< pat.tpe) || fail(pat, pt)
+
     !ctx.settings.strict.value || // only in -strict mode for now since mitigations work only after this PR
     pat.tpe.widen.hasAnnotation(defn.UncheckedAnnot) || {
       pat match {
         case Bind(_, pat1) =>
           checkIrrefutable(pat1, pt)
         case UnApply(fn, _, pats) =>
-          check(pat, pt) && {
-            val argPts = unapplyArgs(fn.tpe.finalResultType, fn, pats, pat.sourcePos)
+          check(pat, pt) &&
+          (isIrrefutableUnapply(fn) || fail(pat, pt)) && {
+            val argPts = unapplyArgs(fn.tpe.widen.finalResultType, fn, pats, pat.sourcePos)
             pats.corresponds(argPts)(checkIrrefutable)
           }
         case Alternative(pats) =>

tests/neg-strict/unchecked-patterns.scala

@@ -1,4 +1,5 @@
 object Test {
+
   val (y1: Some[Int] @unchecked) = Some(1): Option[Int]  // OK
   val y2: Some[Int] @unchecked = Some(1): Option[Int]    // error
 
@@ -7,4 +8,16 @@ object Test {
   val 1 *: cs = 1 *: ()              // error
 
   val (_: Int | _: Any) = ??? : Any  // error
+
+  object Positive { def unapply(i: Int): Option[Int] = Some(i).filter(_ > 0) }
+  object Always1 { def unapply(i: Int): Some[Int] = Some(i) }
+  object Pair { def unapply(t: (Int, Int)): t.type = t }
+  object Triple { def unapply(t: (Int, Int, Int)): (Int, Int, Int) = t }
+
+  val Positive(p) = 5                // error
+  val Some(s1) = Option(1)           // error
+  val Some(s2) = Some(1)             // OK
+  val Always1(p1) = 5                // OK
+  val Pair(t1, t2) = (5, 5)          // OK
+  val Triple(u1, u2, u3) = (5, 5, 5) // OK
 }

tests/run/unchecked-patterns.scala

@@ -5,5 +5,7 @@ object Test extends App {
   val a :: as: @unchecked = List(1, 2, 3)
   val lst @ b :: bs: @unchecked = List(1, 2, 3)
   val (1, c): @unchecked = (1, 2)
-  val 1 *: cs: @unchecked = 1 *: ()        // error
+
+  object Positive { def unapply(i: Int): Option[Int] = Some(i).filter(_ > 0) }
+  val Positive(p): @unchecked = 5
 }