Allow <pattern> : <type> syntax

So far, the pattern in a type ascription had to be a variable. But there are use cases
where we want to have a general pattern in this position.

Author: odersky

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

@@ -1925,12 +1925,11 @@ object Parsers {
       if (isIdent(nme.raw.BAR)) { in.nextToken(); pattern1() :: patternAlts() }
       else Nil
 
-    /**  Pattern1          ::= PatVar Ascription
-     *                      |  Pattern2
+    /**  Pattern1          ::= Pattern2 [Ascription]
      */
     def pattern1(): Tree = {
       val p = pattern2()
-      if (isVarPattern(p) && in.token == COLON) {
+      if (in.token == COLON) {
         in.nextToken()
         ascription(p, Location.InPattern)
       }

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

@@ -339,10 +339,10 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
         }
       else
         Prod(erase(pat.tpe.stripAnnots), erase(fun.tpe), fun.symbol, pats.map(project), isIrrefutableUnapply(fun))
-    case Typed(pat: UnApply, _) =>
-      project(pat)
-    case Typed(expr, tpt) =>
+    case Typed(expr @ Ident(nme.WILDCARD), tpt) =>
       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

docs/docs/internals/syntax.md

@@ -261,8 +261,7 @@ TypeCaseClauses   ::=  TypeCaseClause { TypeCaseClause }
 TypeCaseClause    ::=  ‘case’ InfixType ‘=>’ Type [nl]
 
 Pattern           ::=  Pattern1 { ‘|’ Pattern1 }                                Alternative(pats)
-Pattern1          ::=  PatVar ‘:’ RefinedType                                   Bind(name, Typed(Ident(wildcard), tpe))
-                    |  Pattern2
+Pattern1          ::=  Pattern2 [‘:’ RefinedType]                               Bind(name, Typed(Ident(wildcard), tpe))
 Pattern2          ::=  [id ‘@’] InfixPattern                                    Bind(name, pat)
 InfixPattern      ::=  SimplePattern { id [nl] SimplePattern }                  InfixOp(pat, op, pat)
 SimplePattern     ::=  PatVar                                                   Ident(wildcard)

tests/pos/patmat.scala

@@ -8,15 +8,15 @@ object Test {
 
   xs.length match {
     case 0 => println("0")
-    case 1 => println("1")
+    case 1: Int => println("1")
     case 2 => println("2")
     case 3 => println("3")
     case 4 => println("4")
     case _ => println("something else")
   }
 
   (xs.length, xs) match {
-    case (0, Nil) => println("1")
+    case (0, Nil: List[Int]) => println("1")
     case (_, Nil) => println("2")
     case (0, _)   => println("3")
     case (x, y)   => println("4")
@@ -46,4 +46,9 @@ object Test {
     case Some(s) => println(s)
     case None => println("nothing")
   }
+
+  type IntPair = (Int, Int)
+  ??? match {
+    case (x, y): IntPair => x * y
+  }
 }

tests/run/genericNumLits.scala

@@ -32,18 +32,26 @@ object Test extends App {
   x match {
     case 13232202002020202020202 => ()
   }
+  (x: Any) match {
+    case 13232202002020202020202: BigInt => ()
+  }
   y match {
     case 13232202002020202020202 => assert(false)
     case -0xaabb12345ACF12345AC => ()
   }
   z match {
     case 132322020020.223 => ()
   }
-  z match {
-    case 132322020020.223 => ()
+  (z: Any) match {
+    case 132322020020.223: BigDecimal => ()
   }
 
   e match {
     case 1234 =>
   }
+  (e: Any) match {
+    case 12: Even => assert(false)
+    case 1234: Even =>
+    case _: Even =>
+  }
 }