Treat narrowing pattern definitions as errors

Author: odersky

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

@@ -32,6 +32,9 @@ object desugar {
    */
   val DerivingCompanion: Property.Key[SourcePosition] = new Property.Key
 
+  /** An attachment for match expressions generated from a PatDef */
+  val PatDefMatch: Property.Key[Unit] = new Property.Key
+
   /** Info of a variable in a pattern: The named tree and its type */
   private type VarInfo = (NameTree, Tree)
 
@@ -948,7 +951,11 @@ object desugar {
       // - `pat` is a tuple of N variables or wildcard patterns like `(x1, x2, ..., xN)`
       val tupleOptimizable = forallResults(rhs, isMatchingTuple)
 
-      def rhsUnchecked = makeAnnotated("scala.unchecked", rhs)
+      def rhsUnchecked = {
+        val rhs1 = makeAnnotated("scala.unchecked", rhs)
+        rhs1.pushAttachment(PatDefMatch, ())
+        rhs1
+      }
       val vars =
         if (tupleOptimizable) // include `_`
           pat match {

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

@@ -16,6 +16,8 @@ import ProtoTypes._
 import Scopes._
 import CheckRealizable._
 import ErrorReporting.errorTree
+import rewrites.Rewrites.patch
+import util.Spans.Span
 
 import util.SourcePosition
 import transform.SymUtils._
@@ -594,6 +596,25 @@ trait Checking {
       ctx.error(ex"$cls cannot be instantiated since it${rstatus.msg}", pos)
   }
 
+  /** Check that pattern definition is either marked @unchecked or has a right
+   *  hand side with a type that conforms to the pattern's type.
+   */
+  def checkPatDefMatch(tree: Tree, pt: Type)(implicit ctx: Context): Unit = tree match {
+    case Match(_, CaseDef(pat, _, _) :: _)
+    if !pat.tpe.widen.hasAnnotation(defn.UncheckedAnnot) && !(pt <:< pat.tpe) =>
+      val pt1 = pt match {
+        case AnnotatedType(pt1, annot) if annot.matches(defn.UncheckedAnnot) => pt1
+        case _ => pt
+      }
+      ctx.errorOrMigrationWarning(
+        ex"""pattern's type ${pat.tpe.widen} is more specialized than the right hand side expression's type $pt1
+            |
+            |If the narrowing is intentional, this can be communicated by writing `: @unchecked` after the pattern.${err.rewriteNotice}""",
+        pat.sourcePos)
+      if (ctx.scala2Mode) patch(Span(pat.span.end), ": @unchecked")
+    case _ =>
+  }
+
   /** Check that `path` is a legal prefix for an import or export clause */
   def checkLegalImportPath(path: Tree)(implicit ctx: Context): Unit = {
     checkStable(path.tpe, path.sourcePos)

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

@@ -157,6 +157,10 @@ object ErrorReporting {
       }
       """\$\{\w*\}""".r.replaceSomeIn(raw, m => translate(m.matched.drop(2).init))
     }
+
+    def rewriteNotice: String =
+      if (ctx.scala2Mode) "\nThis patch can be inserted automatically under -rewrite."
+      else ""
   }
 
   def err(implicit ctx: Context): Errors = new Errors

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

@@ -1036,7 +1036,10 @@ class Typer extends Namer
         if (tree.isInline) checkInInlineContext("inline match", tree.posd)
         val sel1 = typedExpr(tree.selector)
         val selType = fullyDefinedType(sel1.tpe, "pattern selector", tree.span).widen
-        typedMatchFinish(tree, sel1, selType, tree.cases, pt)
+        val res = typedMatchFinish(tree, sel1, selType, tree.cases, pt)
+        if (tree.selector.removeAttachment(desugar.PatDefMatch).isDefined)
+          checkPatDefMatch(res, sel1.tpe)
+        res
     }
   }
 

tests/run/unchecked-patterns.scala

@@ -3,6 +3,4 @@ object Test extends App {
   val (y1: Some[Int] @unchecked) = Some(1): Option[Int]
 
   val a :: as: @unchecked = List(1, 2, 3)
-
-
 }