Fix #10614: align unchecked pattern definition syntax with Scala 2

Author: liufengyun

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

@@ -1006,14 +1006,17 @@ object desugar {
    *           - None              :  sel @unchecked
    *           - Exhaustive        :  sel
    *           - IrrefutablePatDef,
-   *             IrrefutableGenFrom:  sel @unchecked with attachment `CheckIrrefutable -> checkMode`
+   *             IrrefutableGenFrom:  sel with attachment `CheckIrrefutable -> checkMode`
    */
   def makeSelector(sel: Tree, checkMode: MatchCheck)(using Context): Tree =
     if (checkMode == MatchCheck.Exhaustive) sel
     else {
-      val sel1 = Annotated(sel, New(ref(defn.UncheckedAnnot.typeRef)))
-      if (checkMode != MatchCheck.None) sel1.pushAttachment(CheckIrrefutable, checkMode)
-      sel1
+      if (checkMode == MatchCheck.None)
+        Annotated(sel, New(ref(defn.UncheckedAnnot.typeRef)))
+      else
+        // TODO: use `pushAttachment` and investigate duplicate attachment
+        sel.withAttachment(CheckIrrefutable, checkMode)
+        sel
     }
 
   /** If `pat` is a variable pattern,

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3184,7 +3184,7 @@ object Parsers {
     }
 
     /** PatDef  ::=  ids [‘:’ Type] ‘=’ Expr
-     *            |  Pattern2 [‘:’ Type | Ascription] ‘=’ Expr
+     *            |  Pattern2 [‘:’ Type] ‘=’ Expr
      *  VarDef  ::=  PatDef | id {`,' id} `:' Type `=' `_'
      *  ValDcl  ::=  id {`,' id} `:' Type
      *  VarDcl  ::=  id {`,' id} `:' Type
@@ -3202,11 +3202,7 @@ object Parsers {
       val tpt =
         if (in.token == COLON) {
           in.nextToken()
-          if (in.token == AT && lhs.tail.isEmpty) {
-            lhs = ascription(first, Location.ElseWhere) :: Nil
-            emptyType
-          }
-          else toplevelTyp()
+          toplevelTyp()
         }
         else emptyType
       val rhs =

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

@@ -671,30 +671,32 @@ trait Checking {
       report.error(ex"$cls cannot be instantiated since it${rstatus.msg}", pos)
   }
 
-  /** Check that pattern `pat` is irrefutable for scrutinee tye `pt`.
-   *  This means `pat` is either marked @unchecked or `pt` conforms to the
+  /** Check that pattern `pat` is irrefutable for scrutinee tye `sel.tpe`.
+   *  This means `sel` is either marked @unchecked or `sel.tpe` conforms to the
    *  pattern's type. If pattern is an UnApply, do the check recursively.
    */
-  def checkIrrefutable(pat: Tree, pt: Type, isPatDef: Boolean)(using Context): Boolean = {
+  def checkIrrefutable(sel: Tree, pat: Tree, isPatDef: Boolean)(using Context): Boolean = {
+    val pt = sel.tpe
 
     def fail(pat: Tree, pt: Type): Boolean = {
       var reportedPt = pt.dropAnnot(defn.UncheckedAnnot)
       if (!pat.tpe.isSingleton) reportedPt = reportedPt.widen
       val problem = if (pat.tpe <:< reportedPt) "is more specialized than" else "does not match"
-      val fix = if (isPatDef) "`: @unchecked` after" else "`case ` before"
+      val fix = if (isPatDef) "adding `: @unchecked` after the expression" else "writing `case ` before the full pattern"
+      val pos = if (isPatDef) sel.srcPos else pat.srcPos
       report.errorOrMigrationWarning(
         ex"""pattern's type ${pat.tpe} $problem the right hand side expression's type $reportedPt
             |
-            |If the narrowing is intentional, this can be communicated by writing $fix the full pattern.${err.rewriteNotice}""",
-        pat.srcPos)
+            |If the narrowing is intentional, this can be communicated by $fix.${err.rewriteNotice}""",
+          pos)
       false
     }
 
     def check(pat: Tree, pt: Type): Boolean = (pt <:< pat.tpe) || fail(pat, pt)
 
     def recur(pat: Tree, pt: Type): Boolean =
       !sourceVersion.isAtLeast(`3.1`) || // only for 3.1 for now since mitigations work only after this PR
-      pat.tpe.widen.hasAnnotation(defn.UncheckedAnnot) || {
+      pt.widen.hasAnnotation(defn.UncheckedAnnot) || {
         patmatch.println(i"check irrefutable $pat: ${pat.tpe} against $pt")
         pat match {
           case Bind(_, pat1) =>

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

@@ -1386,18 +1386,27 @@ class Typer extends Namer
         }
 
         result match {
-          case Match(sel, CaseDef(pat, _, _) :: _) =>
+          case result @ Match(sel, CaseDef(pat, _, _) :: _) =>
             tree.selector.removeAttachment(desugar.CheckIrrefutable) match {
               case Some(checkMode) =>
                 val isPatDef = checkMode == desugar.MatchCheck.IrrefutablePatDef
-                if (!checkIrrefutable(pat, sel.tpe, isPatDef) && sourceVersion == `3.1-migration`)
-                  if (isPatDef) patch(Span(pat.span.end), ": @unchecked")
+                if (!checkIrrefutable(sel, pat, isPatDef) && sourceVersion == `3.1-migration`)
+                  if (isPatDef) patch(Span(tree.selector.span.end), ": @unchecked")
                   else patch(Span(pat.span.start), "case ")
+
+                // skip exhaustivity check in later phase
+                // TODO: move the check above to patternMatcher phase
+                val uncheckedTpe = AnnotatedType(sel.tpe, Annotation(defn.UncheckedAnnot))
+                tpd.cpy.Match(result)(
+                  selector = tpd.Typed(sel, tpd.TypeTree(uncheckedTpe)),
+                  cases = result.cases
+                )
               case _ =>
+                result
             }
           case _ =>
+            result
         }
-        result
     }
 
   /** Special typing of Match tree when the expected type is a MatchType,

docs/docs/internals/syntax.md

@@ -374,7 +374,7 @@ Def               ::=  ‘val’ PatDef
                     |  ‘type’ {nl} TypeDcl
                     |  TmplDef
 PatDef            ::=  ids [‘:’ Type] ‘=’ Expr
-                    |  Pattern2 [‘:’ Type | Ascription] ‘=’ Expr                PatDef(_, pats, tpe?, expr)
+                    |  Pattern2 [‘:’ Type] ‘=’ Expr                PatDef(_, pats, tpe?, expr)
 VarDef            ::=  PatDef
                     |  ids ‘:’ Type ‘=’ ‘_’
 DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr                               DefDef(_, name, tparams, vparamss, tpe, expr)

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

@@ -25,9 +25,9 @@ want to decompose it like this:
 ```scala
 val first :: rest = elems   // error
 ```
-This works in Scala 2. In fact it is a typical use case for Scala 2's rules. But in Scala 3.1 it will give a type error. One can avoid the error by marking the pattern with an `@unchecked` annotation:
+This works in Scala 2. In fact it is a typical use case for Scala 2's rules. But in Scala 3.1 it will give a type error. One can avoid the error by marking the rhs with an `@unchecked` annotation:
 ```scala
-val first :: rest : @unchecked = elems   // OK
+val first :: rest = elems: @unchecked   // OK
 ```
 This will make the compiler accept the pattern binding. It might give an error at runtime instead, if the underlying assumption that `elems` can never be empty is wrong.
 
@@ -49,13 +49,11 @@ The filtering functionality can be obtained in Scala 3 by prefixing the pattern
 
 ## Syntax Changes
 
-There are two syntax changes relative to Scala 2: First, pattern definitions can carry ascriptions such as `: @unchecked`. Second, generators in for expressions may be prefixed with `case`.
+Generators in for expressions may be prefixed with `case`.
 ```
-PatDef         ::=  ids [‘:’ Type] ‘=’ Expr
-                 |  Pattern2 [‘:’ Type | Ascription] ‘=’ Expr
 Generator      ::=  [‘case’] Pattern1 ‘<-’ Expr
 ```
 
 ## Migration
 
-The new syntax is supported in Dotty and Scala 3.0. However, to enable smooth cross compilation between Scala 2 and Scala 3, the changed behavior and additional type checks are only enabled under the `-source 3.1` setting. They will be enabled by default in version 3.1 of the language.
+The new syntax is supported in Scala 3.0. However, to enable smooth cross compilation between Scala 2 and Scala 3, the changed behavior and additional type checks are only enabled under the `-source 3.1` setting. They will be enabled by default in version 3.1 of the language.

docs/docs/reference/syntax.md

@@ -361,7 +361,7 @@ Def               ::=  ‘val’ PatDef
                     |  ‘type’ {nl} TypeDcl
                     |  TmplDef
 PatDef            ::=  ids [‘:’ Type] ‘=’ Expr
-                    |  Pattern2 [‘:’ Type | Ascription] ‘=’ Expr
+                    |  Pattern2 [‘:’ Type] ‘=’ Expr
 VarDef            ::=  PatDef
                     |  ids ‘:’ Type ‘=’ ‘_’
 DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr

tests/neg-strict/unchecked-patterns.scala

@@ -1,13 +1,13 @@
 object Test {
 
-  val (y1: Some[Int] @unchecked) = Some(1): Option[Int]  // OK
+  val (y1: Some[Int]) = Some(1): Option[Int] @unchecked  // OK
   val y2: Some[Int] @unchecked = Some(1): Option[Int]    // error
 
   val x :: xs = List(1, 2, 3)        // error
   val (1, c) = (1, 2)                // error
   val 1 *: cs = 1 *: Tuple()         // error
 
-  val (_: Int | _: Any) = ??? : Any  // error
+  val (_: Int | _: AnyRef) = ??? : AnyRef  // error
 
   val 1 = 2  // error
 

tests/run/unchecked-patterns.scala

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