implemented variant A about allowing , in the simple

Author: rssh

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -576,10 +576,12 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def makeSelfDef(name: TermName, tpt: Tree)(using Context): ValDef =
     ValDef(name, tpt, EmptyTree).withFlags(PrivateLocal)
 
-  def makeTupleOrParens(ts: List[Tree])(using Context): Tree = ts match
-    case (t: NamedArg) :: Nil => Tuple(t :: Nil)
-    case t :: Nil => Parens(t)
-    case _ => Tuple(ts)
+  def makeTupleOrParens(ts: List[Tree], trailingComma: Boolean = false)(using Context): Tree =
+    if trailingComma then Tuple(ts)
+    else ts match
+      case (t: NamedArg) :: Nil => Tuple(t :: Nil)
+      case t :: Nil => Parens(t)
+      case _ => Tuple(ts)
 
   def makeTuple(ts: List[Tree])(using Context): Tree = ts match
     case (t: NamedArg) :: Nil => Tuple(t :: Nil)

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

@@ -660,6 +660,15 @@ object Parsers {
         commaSeparatedRest(part(), part)
       }
 
+    /** Like commaSeparated but also detects trailing comma.
+     *  Returns (list, trailingComma) where trailingComma is true if the list
+     *  ended with a comma followed by a closing token.
+     */
+    def commaSeparatedWithTrailingComma[T](part: () => T): (List[T], Boolean) =
+      in.currentRegion.withCommasExpected {
+        commaSeparatedRestWithTrailingComma(part(), part)
+      }
+
     /** {`,` <part>}
      *
      *  currentRegion.commasExpected has to be set separately.
@@ -673,6 +682,22 @@ object Parsers {
         ts.toList
       else leading :: Nil
 
+    /** Like commaSeparatedRest but also detects trailing comma.
+     *  Returns (list, trailingComma) where trailingComma is true if the list
+     *  ended with a comma followed by a closing token (RPAREN, RBRACKET, RBRACE).
+     *  Used for tuple syntax like (A,) or (a,).
+     */
+    def commaSeparatedRestWithTrailingComma[T](leading: T, part: () => T): (List[T], Boolean) =
+      if in.token == COMMA then
+        val ts = new ListBuffer[T] += leading
+        while in.token == COMMA do
+          in.nextToken()
+          if in.token == RPAREN || in.token == RBRACKET || in.token == RBRACE then
+            return (ts.toList, true)
+          ts += part()
+        (ts.toList, false)
+      else (leading :: Nil, false)
+
     def maybeNamed(op: () => Tree): () => Tree = () =>
       if isIdent && in.lookahead.token == EQUALS && sourceVersion.enablesNamedTuples then
         atSpan(in.offset):
@@ -1798,28 +1823,28 @@ object Parsers {
             erasedArgs.addOne(isErased)
             if isErased then in.skipToken()
           addErased()
-          val args =
+          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)
-                  commaSeparatedRest(
+                  commaSeparatedRestWithTrailingComma(
                     typedFunParam(paramStart, name.toTermName, imods),
                     () => funParam(in.offset, imods))
                 case t =>
                   def funArg() =
                     erasedArgs.addOne(false)
                     funArgType()
-                  commaSeparatedRest(t, funArg)
+                  commaSeparatedRestWithTrailingComma(t, funArg)
           accept(RPAREN)
           if in.isArrow || isPureArrow || erasedArgs.contains(true) then
             functionRest(args)
           else
             val tuple = atSpan(start):
-              makeTupleOrParens(args.mapConserve(convertToElem))
+              makeTupleOrParens(args.mapConserve(convertToElem), trailingComma)
             typeRest:
               infixTypeRest(inContextBound):
                 refinedTypeRest:
@@ -2120,7 +2145,8 @@ object Parsers {
     def simpleType1() = simpleTypeRest {
       if in.token == LPAREN then
         atSpan(in.offset) {
-          makeTupleOrParens(inParensWithCommas(argTypes(namedOK = false, wildOK = true, tupleOK = true)))
+          val (ts, trailingComma) = inParensWithCommas(argTypesWithTrailingComma(namedOK = false, wildOK = true, tupleOK = true))
+          makeTupleOrParens(ts, trailingComma)
         }
       else if in.token == LBRACE then
         atSpan(in.offset) { RefinedTypeTree(EmptyTree, refinement(indentOK = false)) }
@@ -2209,6 +2235,12 @@ object Parsers {
      *    NameAndType       ::=  id ‘:’ Type
      */
     def argTypes(namedOK: Boolean, wildOK: Boolean, tupleOK: Boolean): List[Tree] =
+      argTypesWithTrailingComma(namedOK, wildOK, tupleOK)._1
+
+    /** Like argTypes but also returns whether a trailing comma was present.
+     *  Used for tuple syntax like (A,) to force tuple interpretation.
+     */
+    def argTypesWithTrailingComma(namedOK: Boolean, wildOK: Boolean, tupleOK: Boolean): (List[Tree], Boolean) =
       def wildCardCheck(gen: Tree): Tree =
         val t = gen
         if wildOK then t else rejectWildcardType(t)
@@ -2234,12 +2266,12 @@ object Parsers {
           NamedArg(name, argType())
 
       if namedOK && (isIdent && in.lookahead.token == EQUALS) then
-        commaSeparated(() => namedTypeArg())
+        commaSeparatedWithTrailingComma(() => namedTypeArg())
       else if tupleOK && isIdent && in.lookahead.isColon && sourceVersion.enablesNamedTuples then
-        commaSeparated(() => nameAndType())
+        commaSeparatedWithTrailingComma(() => nameAndType())
       else
-        commaSeparated(() => typeArg())
-    end argTypes
+        commaSeparatedWithTrailingComma(() => typeArg())
+    end argTypesWithTrailingComma
 
     def paramTypeOf(core: () => Tree): Tree =
       if in.token == ARROW || isPureArrow(nme.PUREARROW) then
@@ -2852,7 +2884,10 @@ object Parsers {
           placeholderParams = param :: placeholderParams
           atSpan(start) { Ident(pname) }
         case LPAREN =>
-          atSpan(in.offset) { makeTupleOrParens(inParensWithCommas(exprsInParensOrBindings())) }
+          atSpan(in.offset) {
+            val (ts, trailingComma) = inParensWithCommas(exprsInParensOrBindingsWithTrailingComma())
+            makeTupleOrParens(ts, trailingComma)
+          }
         case LBRACE | INDENT =>
           canApply = false
           blockExpr()
@@ -2948,12 +2983,18 @@ object Parsers {
     end newExpr
 
     /**   ExprsInParens     ::=  ExprInParens {`,' ExprInParens}
-     *                       |   NamedExprInParens {‘,’ NamedExprInParens}
+     *                       |   NamedExprInParens {',' NamedExprInParens}
      *    Bindings          ::=  Binding {`,' Binding}
      *    NamedExprInParens ::=  id '=' ExprInParens
      */
     def exprsInParensOrBindings(): List[Tree] =
-      if in.token == RPAREN then Nil
+      exprsInParensOrBindingsWithTrailingComma()._1
+
+    /** Like exprsInParensOrBindings but also returns whether a trailing comma was present.
+     *  Used for tuple syntax like (a,) to force tuple interpretation.
+     */
+    def exprsInParensOrBindingsWithTrailingComma(): (List[Tree], Boolean) =
+      if in.token == RPAREN then (Nil, false)
       else in.currentRegion.withCommasExpected {
         var isFormalParams = false
         def exprOrBinding() =
@@ -2963,7 +3004,7 @@ object Parsers {
             val t = maybeNamed(exprInParens)()
             if t.isInstanceOf[ValDef] then isFormalParams = true
             t
-        commaSeparatedRest(exprOrBinding(), exprOrBinding)
+        commaSeparatedRestWithTrailingComma(exprOrBinding(), exprOrBinding)
       }
 
     /** ParArgumentExprs ::= `(' [‘using’] [ExprsInParens] `)'
@@ -3375,7 +3416,10 @@ object Parsers {
       case USCORE =>
         wildcardIdent()
       case LPAREN =>
-        atSpan(in.offset) { makeTupleOrParens(inParensWithCommas(patternsOpt())) }
+        atSpan(in.offset) {
+          val (ts, trailingComma) = inParensWithCommas(patternsOptWithTrailingComma())
+          makeTupleOrParens(ts, trailingComma)
+        }
       case QUOTE =>
         simpleExpr(Location.InPattern)
       case XMLSTART =>
@@ -3410,16 +3454,26 @@ object Parsers {
         p
 
     /** Patterns          ::=  Pattern [`,' Pattern]
-     *                      |  NamedPattern {‘,’ NamedPattern}
+     *                      |  NamedPattern {',' NamedPattern}
      *  NamedPattern      ::=  id '=' Pattern
      */
     def patterns(location: Location = Location.InPattern): List[Tree] =
       commaSeparated(maybeNamed(() => pattern(location)))
         // check that patterns are all named or all unnamed is done at desugaring
 
+    /** Like patterns but also returns whether a trailing comma was present. */
+    def patternsWithTrailingComma(location: Location = Location.InPattern): (List[Tree], Boolean) =
+      commaSeparatedWithTrailingComma(maybeNamed(() => pattern(location)))
+
     def patternsOpt(location: Location = Location.InPattern): List[Tree] =
       if (in.token == RPAREN) Nil else patterns(location)
 
+    /** Like patternsOpt but also returns whether a trailing comma was present.
+     *  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)
+
     /** ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
      *                      |  ‘(’ [Patterns ‘,’] PatVar ‘*’ [‘,’ Patterns] ‘)’
      *

tests/pos/tuple-trailing-comma.scala

@@ -0,0 +1,20 @@
+// Test trailing comma syntax for tuples (B variant)
+// This allows (A,) to be a single-element type tuple and (a,) to be a single-element value tuple
+
+object TupleTrailingComma:
+  // Type tuples with trailing comma
+  type T1 = (Int,)                    // single-element type tuple
+  type T2 = (Int, String,)            // trailing comma with multiple elements
+  type T3 = (Int, String)             // regular tuple (should still work)
+
+  // Value tuples with trailing comma
+  val v1: (Int,) = (1,)               // single-element value tuple
+  val v2 = (1, 2,)                    // trailing comma with multiple elements
+  val v3 = (1, 2)                     // regular tuple (should still work)
+
+  // Pattern matching with trailing comma
+  def test(x: Any): Unit = x match
+    case (a,) => println(s"single: $a")
+    case (a, b,) => println(s"pair: $a, $b")
+    case (a, b) => println(s"pair no trailing: $a, $b")
+    case _ => println("other")