Use p* for vararg patterns

odersky · odersky · commit 217e8dcbcaab · 2021-01-28T11:22:42.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1524,7 +1524,7 @@ object Parsers {
 
     /** Is current ident a `*`, and is it followed by a `)` or `,`? */
     def isPostfixStar: Boolean =
-      in.name == nme.raw.STAR && {
+      in.isIdent(nme.raw.STAR) && {
         val nxt = in.lookahead.token
         nxt == RPAREN || nxt == COMMA
       }
@@ -2610,37 +2610,43 @@ object Parsers {
         ascription(p, location)
       else p
 
-    /**  Pattern2    ::=  [id `as'] InfixPattern
+    /**  Pattern2    ::=  InfixPattern [‘*’]
      */
-    val pattern2: () => Tree = () => infixPattern() match {
+    def pattern3(): Tree =
+      val p = infixPattern()
+      if isPostfixStar then
+        atSpan(in.skipToken()) {
+          Typed(p, Ident(tpnme.WILDCARD_STAR))
+        }
+      else p
+
+    /**  Pattern2    ::=  [id `@'] Pattern3
+     */
+    val pattern2: () => Tree = () => pattern3() match
       case p @ Ident(name) if in.token == AT =>
         val offset = in.skipToken()
-        infixPattern() match {
-          case pt @ Ident(tpnme.WILDCARD_STAR) =>  // compatibility for Scala2 `x @ _*` syntax
-            warnMigration(p)
-            atSpan(startOffset(p), offset) { Typed(p, pt) }
+        pattern3() match {
           case pt @ Bind(nme.WILDCARD, pt1: Typed) if pt.mods.is(Given) =>
             atSpan(startOffset(p), 0) { Bind(name, pt1).withMods(pt.mods) }
+          case Typed(Ident(nme.WILDCARD), pt @ Ident(tpnme.WILDCARD_STAR)) =>
+            atSpan(startOffset(p), 0) { Typed(p, pt) }
           case pt =>
             atSpan(startOffset(p), 0) { Bind(name, pt) }
         }
-      case p @ Ident(tpnme.WILDCARD_STAR) =>
-        warnMigration(p)
-        atSpan(startOffset(p)) { Typed(Ident(nme.WILDCARD), p) }
       case p =>
         p
-    }
 
-    private def warnMigration(p: Tree) =
+    private def warnStarMigration(p: Tree) =
       if sourceVersion.isAtLeast(`3.1`) then
         report.errorOrMigrationWarning(
-          "The syntax `x @ _*` is no longer supported; use `x : _*` instead",
+          em"The syntax `x: _*` is no longer supported for vararg splices; use `x*` instead",
           in.sourcePos(startOffset(p)))
 
     /**  InfixPattern ::= SimplePattern {id [nl] SimplePattern}
      */
     def infixPattern(): Tree =
-      infixOps(simplePattern(), in.canStartExprTokens, simplePattern, isOperator = in.name != nme.raw.BAR)
+      infixOps(simplePattern(), in.canStartExprTokens, simplePattern,
+          isOperator = in.name != nme.raw.BAR && !isPostfixStar)
 
     /** SimplePattern    ::= PatVar
      *                    |  Literal
@@ -2659,16 +2665,7 @@ object Parsers {
           case id @ Ident(nme.raw.MINUS) if isNumericLit => literal(startOffset(id))
           case t => simplePatternRest(t)
       case USCORE =>
-        val wildIdent = wildcardIdent()
-
-        // compatibility for Scala2 `x @ _*` and `_*` syntax
-        // `x: _*' is parsed in `ascription'
-        if (isIdent(nme.raw.STAR)) {
-          in.nextToken()
-          if (in.token != RPAREN) syntaxError(SeqWildcardPatternPos(), wildIdent.span)
-          atSpan(wildIdent.span) { Ident(tpnme.WILDCARD_STAR) }
-        }
-        else wildIdent
+        wildcardIdent()
       case LPAREN =>
         atSpan(in.offset) { makeTupleOrParens(inParens(patternsOpt())) }
       case QUOTE =>
@@ -2710,7 +2707,7 @@ object Parsers {
       if (in.token == RPAREN) Nil else patterns(location)
 
     /** ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
-     *                      |  ‘(’ [Patterns ‘,’] Pattern2 ‘:’ ‘_’ ‘*’ ‘)’
+     *                      |  ‘(’ [Patterns ‘,’] Pattern2 ‘*’ ‘)’
      */
     def argumentPatterns(): List[Tree] =
       inParens(patternsOpt(Location.InPatternArgs))
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -415,10 +415,20 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         }
       case Typed(expr, tpt) =>
         changePrec(InfixPrec) {
-          val exprText = toText(expr)
-          val line = exprText.lastLine
-          val colon = if (!line.isEmpty && isOperatorPart(line.last)) " :" else ":"
-          exprText ~ colon ~ toText(tpt) }
+          if isWildcardStarArg(tree) then
+            expr match
+              case Ident(nme.WILDCARD_STAR) =>
+              	// `_*` is used as a wildcard name to indicate a vararg splice pattern;
+              	// avoid the double `*` in this case.
+              	toText(expr)
+              case _ =>
+                toText(expr) ~ "*"
+          else
+            val exprText = toText(expr)
+            val line = exprText.lastLine
+            val colon = if !line.isEmpty && isOperatorPart(line.last) then " :" else ":"
+            exprText ~ colon ~ toText(tpt)
+        }
       case NamedArg(name, arg) =>
         toText(name) ~ " = " ~ toText(arg)
       case Assign(lhs, rhs) =>
diff --git a/docs/docs/internals/syntax.md b/docs/docs/internals/syntax.md
@@ -252,7 +252,7 @@ ExprsInParens     ::=  ExprInParens {‘,’ ExprInParens}
 ExprInParens      ::=  PostfixExpr ‘:’ Type                                     -- normal Expr allows only RefinedType here
                     |  Expr
 ParArgumentExprs  ::=  ‘(’ [‘using’] ExprsInParens ‘)’                          exprs
-                    |  ‘(’ [ExprsInParens ‘,’] PostfixExpr ‘:’ ‘_’ ‘*’ ‘)’      exprs :+ Typed(expr, Ident(wildcardStar))
+                    |  ‘(’ [ExprsInParens ‘,’] PostfixExpr ‘*’ ‘)’              exprs :+ Typed(expr, Ident(wildcardStar))
 ArgumentExprs     ::=  ParArgumentExprs
                     |  BlockExpr
 BlockExpr         ::=  <<< (CaseClauses | Block) >>>
@@ -297,7 +297,7 @@ PatVar            ::=  varid
                     |  ‘_’
 Patterns          ::=  Pattern {‘,’ Pattern}
 ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’                                       Apply(fn, pats)
-                    |  ‘(’ [Patterns ‘,’] Pattern2 ‘:’ ‘_’ ‘*’ ‘)’
+                    |  ‘(’ [Patterns ‘,’] Pattern2 ‘*’ ‘)’
 ```
 
 ### Type and Value Parameters
diff --git a/docs/docs/reference/syntax.md b/docs/docs/reference/syntax.md
@@ -248,7 +248,7 @@ ExprsInParens     ::=  ExprInParens {‘,’ ExprInParens}
 ExprInParens      ::=  PostfixExpr ‘:’ Type
                     |  Expr
 ParArgumentExprs  ::=  ‘(’ [‘using’] ExprsInParens ‘)’
-                    |  ‘(’ [ExprsInParens ‘,’] PostfixExpr ‘:’ ‘_’ ‘*’ ‘)’
+                    |  ‘(’ [ExprsInParens ‘,’] PostfixExpr ‘*’ ‘)’
 ArgumentExprs     ::=  ParArgumentExprs
                     |  BlockExpr
 BlockExpr         ::=  <<< (CaseClauses | Block) >>>
@@ -277,7 +277,7 @@ TypeCaseClause    ::=  ‘case’ InfixType ‘=>’ Type [nl]
 
 Pattern           ::=  Pattern1 { ‘|’ Pattern1 }
 Pattern1          ::=  Pattern2 [‘:’ RefinedType]
-Pattern2          ::=  [id ‘@’] InfixPattern
+Pattern2          ::=  [id ‘@’] InfixPattern [‘*’]
 InfixPattern      ::=  SimplePattern { id [nl] SimplePattern }
 SimplePattern     ::=  PatVar
                     |  Literal
@@ -291,7 +291,7 @@ PatVar            ::=  varid
                     |  ‘_’
 Patterns          ::=  Pattern {‘,’ Pattern}
 ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
-                    |  ‘(’ [Patterns ‘,’] Pattern2 ‘:’ ‘_’ ‘*’ ‘)’
+                    |  ‘(’ [Patterns ‘,’] Pattern2 ‘*’ ‘)’
 ```
 
 ### Type and Value Parameters
diff --git a/tests/invalid/pos/t3577.scala b/tests/invalid/pos/t3577.scala
diff --git a/tests/neg/t5702-neg-bad-and-wild.scala b/tests/neg/t5702-neg-bad-and-wild.scala
@@ -7,13 +7,13 @@ object Test {
     val is = List(1,2,3)
 
     is match {
-      case List(1, _*,) => // error // error // error: bad use of _* (a sequence pattern must be the last pattern)
+      case List(1, _*,) => // error // // error: bad use of _* (a sequence pattern must be the last pattern)
                            // illegal start of simple pattern
-      case List(1, _*3,) => // error // error: illegal start of simple pattern
+      case List(1, _*3,) => // error // error // error: illegal start of simple pattern
       //case List(1, _*3:) =>  // poor recovery by parens
-      case List(1, x*) => // error: use _* to match a sequence
-      case List(x*, 1) => // error: trailing * is not a valid pattern
-      case (1, x*) => // error: trailing * is not a valid pattern
+      case List(1, x*) => // ok
+      case List(x*, 1) => //ok
+      case (1, x*) => //ok
       case (1, x: _*) => // error: bad use of _* (sequence pattern not allowed)
     }
 
diff --git a/tests/pos/i1059.scala b/tests/pos/i1059.scala
diff --git a/tests/pos/t3577.scala b/tests/pos/t3577.scala
@@ -0,0 +1,12 @@
+case class Check[A](val value: A)
+
+case class C2(checks: Check[_]*);
+
+object C {
+  def m(x : C2): Any = (null: Any) match {
+    case C2(_, rest*) => {
+      rest.map(_.value)
+    }
+  }
+}
+
