Add preserveTrailingComma flag and empty tuple (,) syntax

- Add preserveTrailingComma flag to Scanner Region class to prevent
  trailing comma from being silently consumed in tuple contexts
- Update Parser to use the flag in expression, type, and pattern parsing
- Implement empty tuple syntax (,) for expressions, types, and patterns
- Add inParensWithTrailingComma helper for cleaner tuple parsing
- Ensure (a,<newline>) and (a, b,<newline>) are correctly parsed as tuples
- Add tests for single/multi-element tuples, empty tuples, and multiline variants

Author: rssh

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

@@ -641,6 +641,19 @@ object Parsers {
     def inParensWithCommas[T](body: => T): T = enclosedWithCommas(LPAREN, body)
     def inBracketsWithCommas[T](body: => T): T = enclosedWithCommas(LBRACKET, body)
 
+    /** Like inParensWithCommas but also preserves trailing comma for tuple detection. */
+    def inParensWithTrailingComma[T](body: => T): T =
+      accept(LPAREN)
+      in.currentRegion.withPreserveTrailingComma:
+        val closing = RPAREN
+        val isEmpty = in.token == closing
+        val ts = body
+        if in.token != closing then
+          val prefix = if !isEmpty && canStartExprTokens3.contains(in.token) then "',' or " else ""
+          syntaxErrorOrIncomplete(ExpectedTokenButFound(closing, in.token, prefix))
+        if in.token == closing then in.nextToken()
+        ts
+
     def inBracesOrIndented[T](body: => T, rewriteWithColon: Boolean = false): T =
       if in.token == INDENT then
         val rewriteToBraces = in.rewriteNoIndent
@@ -1817,28 +1830,40 @@ object Parsers {
         if in.token == RPAREN then
           in.nextToken()
           functionRest(Nil)
+        else if in.token == COMMA then
+          // Empty tuple with comma: (,)
+          in.nextToken()
+          accept(RPAREN)
+          val tuple = atSpan(start)(makeTupleOrParens(Nil, trailingComma = true))
+          typeRest:
+            infixTypeRest(inContextBound):
+              refinedTypeRest:
+                withTypeRest:
+                  annotTypeRest:
+                    simpleTypeRest(tuple)
         else
           val paramStart = in.offset
           def addErased() =
             erasedArgs.addOne(isErased)
             if isErased then in.skipToken()
           addErased()
           val (args, trailingComma) =
-            in.currentRegion.withCommasExpected:
-              funArgType() match
-                case Ident(name) if name != tpnme.WILDCARD && in.isColon =>
-                  def funParam(start: Offset, mods: Modifiers) =
-                    atSpan(start):
-                      addErased()
-                      typedFunParam(in.offset, ident(), imods)
-                  commaSeparatedRestWithTrailingComma(
-                    typedFunParam(paramStart, name.toTermName, imods),
-                    () => funParam(in.offset, imods))
-                case t =>
-                  def funArg() =
-                    erasedArgs.addOne(false)
-                    funArgType()
-                  commaSeparatedRestWithTrailingComma(t, funArg)
+            in.currentRegion.withPreserveTrailingComma:
+              in.currentRegion.withCommasExpected:
+                funArgType() match
+                  case Ident(name) if name != tpnme.WILDCARD && in.isColon =>
+                    def funParam(start: Offset, mods: Modifiers) =
+                      atSpan(start):
+                        addErased()
+                        typedFunParam(in.offset, ident(), imods)
+                    commaSeparatedRestWithTrailingComma(
+                      typedFunParam(paramStart, name.toTermName, imods),
+                      () => funParam(in.offset, imods))
+                  case t =>
+                    def funArg() =
+                      erasedArgs.addOne(false)
+                      funArgType()
+                    commaSeparatedRestWithTrailingComma(t, funArg)
           accept(RPAREN)
           if in.isArrow || isPureArrow || erasedArgs.contains(true) then
             functionRest(args)
@@ -2885,7 +2910,7 @@ object Parsers {
           atSpan(start) { Ident(pname) }
         case LPAREN =>
           atSpan(in.offset) {
-            val (ts, trailingComma) = inParensWithCommas(exprsInParensOrBindingsWithTrailingComma())
+            val (ts, trailingComma) = inParensWithTrailingComma(exprsInParensOrBindingsWithTrailingComma())
             makeTupleOrParens(ts, trailingComma)
           }
         case LBRACE | INDENT =>
@@ -2995,6 +3020,9 @@ object Parsers {
      */
     def exprsInParensOrBindingsWithTrailingComma(): (List[Tree], Boolean) =
       if in.token == RPAREN then (Nil, false)
+      else if in.token == COMMA then
+        in.nextToken()  // skip the comma
+        (Nil, true)     // empty tuple with comma: (,)
       else in.currentRegion.withCommasExpected {
         var isFormalParams = false
         def exprOrBinding() =
@@ -3417,7 +3445,7 @@ object Parsers {
         wildcardIdent()
       case LPAREN =>
         atSpan(in.offset) {
-          val (ts, trailingComma) = inParensWithCommas(patternsOptWithTrailingComma())
+          val (ts, trailingComma) = inParensWithTrailingComma(patternsOptWithTrailingComma())
           makeTupleOrParens(ts, trailingComma)
         }
       case QUOTE =>
@@ -3472,7 +3500,11 @@ object Parsers {
      *  Used for tuple syntax like (a,) to force tuple interpretation.
      */
     def patternsOptWithTrailingComma(location: Location = Location.InPattern): (List[Tree], Boolean) =
-      if in.token == RPAREN then (Nil, false) else patternsWithTrailingComma(location)
+      if in.token == RPAREN then (Nil, false)
+      else if in.token == COMMA then
+        in.nextToken()  // skip the comma
+        (Nil, true)     // empty tuple with comma: (,)
+      else patternsWithTrailingComma(location)
 
     /** ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
      *                      |  ‘(’ [Patterns ‘,’] PatVar ‘*’ [‘,’ Patterns] ‘)’

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

@@ -770,6 +770,7 @@ object Scanners {
               peekAhead()
               if isAfterLineEnd
                  && currentRegion.commasExpected
+                 && !currentRegion.preserveTrailingComma
                  && (token == RPAREN || token == RBRACKET || token == RBRACE || token == OUTDENT)
               then
                 // encountered a trailing comma
@@ -1661,6 +1662,17 @@ object Scanners {
 
     def commasExpected = myCommasExpected
 
+    private var myPreserveTrailingComma: Boolean = false
+
+    inline def withPreserveTrailingComma[T](inline op: => T): T =
+      val saved = myPreserveTrailingComma
+      myPreserveTrailingComma = true
+      val res = op
+      myPreserveTrailingComma = saved
+      res
+
+    def preserveTrailingComma = myPreserveTrailingComma
+
     def toList: List[Region] =
       this :: (if outer == null then Nil else outer.toList)
 

tests/pos/tuple-trailing-comma.scala

@@ -1,5 +1,6 @@
-// Test trailing comma syntax for tuples (B variant)
+// Test trailing comma syntax for tuples (full variant)
 // This allows (A,) to be a single-element type tuple and (a,) to be a single-element value tuple
+// Also allows trailing comma for multi-element tuples like (a, b,)
 
 object TupleTrailingComma:
   // Type tuples with trailing comma
@@ -18,3 +19,37 @@ object TupleTrailingComma:
     case (a, b,) => println(s"pair: $a, $b")
     case (a, b) => println(s"pair no trailing: $a, $b")
     case _ => println("other")
+
+  // With newlines - trailing comma should still be recognized
+  val v4: (Int,
+  ) = (1,
+  )
+
+  val v5: (Int, String,
+  ) = (1, "hello",
+  )
+
+  type T4 = (Int,
+  )
+
+  type T5 = (Int, String,
+  )
+
+  def test2(x: Any): Unit = x match
+    case (a,
+    ) => println(s"single with newline: $a")
+    case (a, b,
+    ) => println(s"pair with newline: $a, $b")
+    case _ => println("other")
+
+  // Empty tuple syntax
+  val empty1: (,) = (,)
+  val empty2: (,
+  ) = (,
+  )
+
+  type EmptyT = (,)
+
+  def testEmpty(x: Any): Unit = x match
+    case (,) => println("empty tuple")
+    case _ => println("other")