Use p* for vararg splices in expressions

Author: odersky

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

@@ -919,7 +919,20 @@ object Parsers {
       val next = in.lookahead.token
       next == LBRACKET || next == LPAREN
 
-/* --------- OPERAND/OPERATOR STACK --------------------------------------- */
+    /** Is current ident a `*`, and is it followed by a `)` or `, )`? */
+    def followingIsVararg(): Boolean =
+      in.isIdent(nme.raw.STAR) && {
+        val lookahead = in.LookaheadScanner()
+        lookahead.nextToken()
+        lookahead.token == RPAREN
+        || lookahead.token == COMMA
+           && {
+             lookahead.nextToken()
+             lookahead.token == RPAREN
+           }
+      }
+
+  /* --------- OPERAND/OPERATOR STACK --------------------------------------- */
 
     var opStack: List[OpInfo] = Nil
 
@@ -956,8 +969,8 @@ object Parsers {
      */
     def infixOps(
         first: Tree, canStartOperand: Token => Boolean, operand: () => Tree,
-        isType: Boolean = false,
-        isOperator: => Boolean = true,
+        isType: Boolean,
+        isOperator: => Boolean,
         maybePostfix: Boolean = false): Tree = {
       val base = opStack
 
@@ -1522,15 +1535,9 @@ object Parsers {
      */
     def infixType(): Tree = infixTypeRest(refinedType())
 
-    /** Is current ident a `*`, and is it followed by a `)` or `,`? */
-    def isPostfixStar: Boolean =
-      in.isIdent(nme.raw.STAR) && {
-        val nxt = in.lookahead.token
-        nxt == RPAREN || nxt == COMMA
-      }
-
     def infixTypeRest(t: Tree): Tree =
-      infixOps(t, canStartTypeTokens, refinedType, isType = true, isOperator = !isPostfixStar)
+      infixOps(t, canStartTypeTokens, refinedType, isType = true,
+        isOperator = !followingIsVararg())
 
     /** RefinedType   ::=  WithType {[nl] Refinement}
      */
@@ -2046,7 +2053,7 @@ object Parsers {
                 case t =>
                   syntaxError(em"`inline` must be followed by an `if` or a `match`", start)
                   t
-        else expr1Rest(postfixExpr(), location)
+        else expr1Rest(postfixExpr(location), location)
     end expr1
 
     def expr1Rest(t: Tree, location: Location): Tree = in.token match
@@ -2068,22 +2075,23 @@ object Parsers {
 
     def ascription(t: Tree, location: Location): Tree = atSpan(startOffset(t)) {
       in.token match {
-        case USCORE =>
+        case USCORE if in.lookahead.isIdent(nme.raw.STAR) =>
           val uscoreStart = in.skipToken()
-          if isIdent(nme.raw.STAR) then
-            in.nextToken()
-            if !(location.inArgs && in.token == RPAREN) then
-              if opStack.nonEmpty then
-                report.errorOrMigrationWarning(
-                  em"""`_*` can be used only for last argument of method application.
-                      |It is no longer allowed in operands of infix operations.""",
-                  in.sourcePos(uscoreStart))
-              else
-                syntaxError(SeqWildcardPatternPos(), uscoreStart)
-            Typed(t, atSpan(uscoreStart) { Ident(tpnme.WILDCARD_STAR) })
+          val isVarargSplice = location.inArgs && followingIsVararg()
+          in.nextToken()
+          if isVarargSplice then
+            if sourceVersion.isAtLeast(`3.1`) then
+              report.errorOrMigrationWarning(
+                em"The syntax `x: _*` is no longer supported for vararg splices; use `x*` instead",
+                in.sourcePos(uscoreStart))
+          else if opStack.nonEmpty then
+            report.errorOrMigrationWarning(
+              em"""`_*` can be used only for last argument of method application.
+                  |It is no longer allowed in operands of infix operations.""",
+              in.sourcePos(uscoreStart))
           else
-            syntaxErrorOrIncomplete(IncorrectRepeatedParameterSyntax())
-            t
+            syntaxError(SeqWildcardPatternPos(), uscoreStart)
+          Typed(t, atSpan(uscoreStart) { Ident(tpnme.WILDCARD_STAR) })
         case AT if !location.inPattern =>
           annotations().foldLeft(t)(Annotated)
         case _ =>
@@ -2200,10 +2208,18 @@ object Parsers {
      *                  | InfixExpr id [nl] InfixExpr
      *                  | InfixExpr MatchClause
      */
-    def postfixExpr(): Tree = postfixExprRest(prefixExpr())
+    def postfixExpr(location: Location = Location.ElseWhere): Tree =
+      val t = postfixExprRest(prefixExpr(), location)
+      if location.inArgs && followingIsVararg() then
+        Typed(t, atSpan(in.skipToken()) { Ident(tpnme.WILDCARD_STAR) })
+      else
+        t
 
-    def postfixExprRest(t: Tree): Tree =
-      infixOps(t, in.canStartExprTokens, prefixExpr, maybePostfix = true)
+    def postfixExprRest(t: Tree, location: Location = Location.ElseWhere): Tree =
+      infixOps(t, in.canStartExprTokens, prefixExpr,
+        isType = false,
+        isOperator = !(location.inArgs && followingIsVararg()),
+        maybePostfix = true)
 
     /** PrefixExpr   ::= [`-' | `+' | `~' | `!'] SimpleExpr
     */
@@ -2331,7 +2347,7 @@ object Parsers {
       if (in.token == RPAREN) Nil else commaSeparated(exprInParens)
 
     /** ParArgumentExprs ::= `(' [‘using’] [ExprsInParens] `)'
-     *                    |  `(' [ExprsInParens `,'] PostfixExpr `:' `_' `*' ')'
+     *                    |  `(' [ExprsInParens `,'] PostfixExpr `*' ')'
      */
     def parArgumentExprs(): (List[Tree], Boolean) = inParens {
       if in.token == RPAREN then
@@ -2614,7 +2630,7 @@ object Parsers {
      */
     def pattern3(): Tree =
       val p = infixPattern()
-      if isPostfixStar then
+      if followingIsVararg() then
         atSpan(in.skipToken()) {
           Typed(p, Ident(tpnme.WILDCARD_STAR))
         }
@@ -2646,7 +2662,8 @@ object Parsers {
      */
     def infixPattern(): Tree =
       infixOps(simplePattern(), in.canStartExprTokens, simplePattern,
-          isOperator = in.name != nme.raw.BAR && !isPostfixStar)
+        isType = false,
+        isOperator = in.name != nme.raw.BAR && !followingIsVararg())
 
     /** SimplePattern    ::= PatVar
      *                    |  Literal

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -35,7 +35,7 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     IllegalVariableInPatternAlternativeID,
     IdentifierExpectedID,
     AuxConstructorNeedsNonImplicitParameterID,
-    IncorrectRepeatedParameterSyntaxID,
+    VarArgsParamMustComeLastID,
     IllegalLiteralID,
     PatternMatchExhaustivityID,
     MatchCaseUnreachableID,

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -779,32 +779,6 @@ import transform.SymUtils._
            |"""
   }
 
-  class IncorrectRepeatedParameterSyntax()(using Context)
-  extends SyntaxMsg(IncorrectRepeatedParameterSyntaxID) {
-    def msg = "'*' expected"
-    def explain =
-      em"""|Expected * in ${hl("_*")} operator.
-           |
-           |The ${hl("_*")} operator can be used to supply a sequence-based argument
-           |to a method with a variable-length or repeated parameter. It is used
-           |to expand the sequence to a variable number of arguments, such that:
-           |${hl("func(args: _*)")} would expand to ${hl("func(arg1, arg2 ... argN)")}.
-           |
-           |Below is an example of how a method with a variable-length
-           |parameter can be declared and used.
-           |
-           |Squares the arguments of a variable-length parameter:
-           |${hl("def square(args: Int*) = args.map(a => a * a)")}
-           |
-           |Usage:
-           |${hl("square(1, 2, 3) // res0: List[Int] = List(1, 4, 9)")}
-           |
-           |Secondary Usage with ${hl("_*")}:
-           |${hl("val ints = List(2, 3, 4)  // ints: List[Int] = List(2, 3, 4)")}
-           |${hl("square(ints: _*)          // res1: List[Int] = List(4, 9, 16)")}
-           |""".stripMargin
-  }
-
   class IllegalLiteral()(using Context)
   extends SyntaxMsg(IllegalLiteralID) {
     def msg = "Illegal literal"
@@ -865,11 +839,11 @@ import transform.SymUtils._
 
   class SeqWildcardPatternPos()(using Context)
   extends SyntaxMsg(SeqWildcardPatternPosID) {
-    def msg = em"""${hl("_*")} can be used only for last argument"""
+    def msg = em"""${hl("*")} can be used only for last argument"""
     def explain = {
       val code =
         """def sumOfTheFirstTwo(list: List[Int]): Int = list match {
-          |  case List(first, second, x:_*) => first + second
+          |  case List(first, second, x*) => first + second
           |  case _ => 0
           |}"""
       em"""|Sequence wildcard pattern is expected at the end of an argument list.
@@ -1274,7 +1248,7 @@ import transform.SymUtils._
   }
 
   class VarArgsParamMustComeLast()(using Context)
-  extends SyntaxMsg(IncorrectRepeatedParameterSyntaxID) {
+  extends SyntaxMsg(VarArgsParamMustComeLastID) {
     def msg = em"""${hl("varargs")} parameter must come last"""
     def explain =
       em"""|The ${hl("varargs")} field must be the last field in the method signature.

tests/neg/t1625.scala

@@ -1,3 +1,3 @@
 trait T3 {
-  def foo(x: String*, y: String*, c: String*): Int // error // error: varargs parameter must come last
+  def foo(x: String*, y: String*, c: String*): Int // error: an identifier expected, but ',' found
 }

tests/neg/t1625b.scala

@@ -1,3 +1,3 @@
 object T5 {
-  case class Abc(x: String*, c: String*) // error // error: varargs parameter must come last AND found: String* required: String
+  case class Abc(x: String*, c: String*) // error: identifier expected but `,` found
 }

tests/neg/t5702-neg-bad-and-wild.scala

@@ -12,7 +12,7 @@ object Test {
       case List(1, _*3,) => // error // error // error: illegal start of simple pattern
       //case List(1, _*3:) =>  // poor recovery by parens
       case List(1, x*) => // ok
-      case List(x*, 1) => //ok
+      case List(x*, 1) => // error: pattern expected
       case (1, x*) => //ok
       case (1, x: _*) => // error: bad use of _* (sequence pattern not allowed)
     }