Allow ascriptions in pattern definitions

Author: odersky

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

@@ -1325,6 +1325,7 @@ object Parsers {
              t
          }
       case COLON =>
+        in.nextToken()
         val t1 = ascription(t, location)
         if (in.token == MATCH) expr1Rest(t1, location) else t1
       case MATCH =>
@@ -1334,7 +1335,6 @@ object Parsers {
     }
 
     def ascription(t: Tree, location: Location.Value): Tree = atSpan(startOffset(t)) {
-      in.skipToken()
       in.token match {
         case USCORE =>
           val uscoreStart = in.skipToken()
@@ -1803,7 +1803,10 @@ object Parsers {
      */
     def pattern1(): Tree = {
       val p = pattern2()
-      if (isVarPattern(p) && in.token == COLON) ascription(p, Location.InPattern)
+      if (isVarPattern(p) && in.token == COLON) {
+        in.nextToken()
+        ascription(p, Location.InPattern)
+      }
       else p
     }
 
@@ -2356,21 +2359,31 @@ object Parsers {
     }
 
     /** PatDef  ::=  ids [‘:’ Type] ‘=’ Expr
-     *            |  Pattern2 [‘:’ Type] ‘=’ Expr
+     *            |  Pattern2 [‘:’ Type | Ascription] ‘=’ Expr
      *  VarDef  ::=  PatDef | id {`,' id} `:' Type `=' `_'
      *  ValDcl  ::=  id {`,' id} `:' Type
      *  VarDcl  ::=  id {`,' id} `:' Type
      */
     def patDefOrDcl(start: Offset, mods: Modifiers): Tree = atSpan(start, nameStart) {
       val first = pattern2()
-      val lhs = first match {
+      var lhs = first match {
         case id: Ident if in.token == COMMA =>
           in.nextToken()
           id :: commaSeparated(() => termIdent())
         case _ =>
           first :: Nil
       }
-      val tpt = typedOpt()
+      def emptyType = TypeTree().withSpan(Span(in.lastOffset))
+      val tpt =
+        if (in.token == COLON) {
+          in.nextToken()
+          if (in.token == AT && lhs.tail.isEmpty) {
+            lhs = ascription(first, Location.ElseWhere) :: Nil
+            emptyType
+          }
+          else toplevelTyp()
+        }
+        else emptyType
       val rhs =
         if (tpt.isEmpty || in.token == EQUALS) {
           accept(EQUALS)
@@ -2384,9 +2397,9 @@ object Parsers {
       lhs match {
         case (id: BackquotedIdent) :: Nil if id.name.isTermName =>
           finalizeDef(BackquotedValDef(id.name.asTermName, tpt, rhs), mods, start)
-        case Ident(name: TermName) :: Nil => {
+        case Ident(name: TermName) :: Nil =>
           finalizeDef(ValDef(name, tpt, rhs), mods, start)
-        } case _ =>
+        case _ =>
           PatDef(mods, lhs, tpt, rhs)
       }
     }

docs/docs/internals/syntax.md

@@ -360,7 +360,7 @@ Def               ::=  ‘val’ PatDef
                     |  TmplDef
                     |  INT
 PatDef            ::=  ids [‘:’ Type] ‘=’ Expr
-                    |  Pattern2 [‘:’ Type] ‘=’ Expr                PatDef(_, pats, tpe?, expr)
+                    |  Pattern2 [‘:’ Type | Ascription] ‘=’ Expr                PatDef(_, pats, tpe?, expr)
 VarDef            ::=  PatDef
                     |  ids ‘:’ Type ‘=’ ‘_’
 DefDef            ::=  DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr                      DefDef(_, name, tparams, vparamss, tpe, expr)

tests/neg/unchecked-patterns.scala

@@ -0,0 +1,4 @@
+object Test {
+  val (y1: Some[Int] @unchecked) = Some(1): Option[Int]  // OK
+  val y2: Some[Int] @unchecked = Some(1): Option[Int]    // error
+}

tests/run/unchecked-patterns.scala

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