SE-0439: Update to address acceptance decision (#2623)

* SE-0439: Update to address acceptance decision

* Update 0439-trailing-comma-lists.md

* Update SE-0439 with link to previous revision

---------

Co-authored-by: Xiaodi Wu <[email protected]>

Author: mateusrodriguesxyz

proposals/0439-trailing-comma-lists.md

@@ -4,13 +4,14 @@
 * Author: [Mateus Rodrigues](https://github.com/mateusrodriguesxyz)
 * Review Manager: [Xiaodi Wu](https://github.com/xwu)
 * Status: **Accepted with modifications**
-* Implementation: https://github.com/swiftlang/swift/pull/74522# gated behind `-enable-experimental-feature TrailingComma`
+* Implementation: `main` https://github.com/swiftlang/swift/pull/74522#
 * Previous Proposal: [SE-0084](0084-trailing-commas.md)
 * Review: ([pitch](https://forums.swift.org/t/pitch-allow-trailing-comma-in-tuples-arguments-and-if-guard-while-conditions/70170)), ([review](https://forums.swift.org/t/se-0439-allow-trailing-comma-in-comma-separated-lists/72876)), ([acceptance](https://forums.swift.org/t/accepted-with-modifications-se-0439-allow-trailing-comma-in-comma-separated-lists/73216))
+* Previous Revision: ([1](https://github.com/swiftlang/swift-evolution/blob/7864fa20cfb3a43aa6874feedb5aedb8be02da2c/proposals/0439-trailing-comma-lists.md))
 
 ## Introduction
 
-This proposal aims to allow the use of trailing commas, currently restricted to array and dictionary literals, in comma-separated lists whenever there are terminators that enable unambiguous parsing.
+This proposal aims to allow the use of trailing commas, currently restricted to array and dictionary literals, in symmetrically delimited comma-separated lists.
 
 ## Motivation
 
@@ -48,7 +49,7 @@ The language has also seen the introduction of [parameter packs](https://github.
 
 ## Proposed solution
 
-This proposal adds support for trailing commas in comma-separated lists when there's a clear terminator, which are the following:
+This proposal adds support for trailing commas in symmetrically delimited comma-separated lists, which are the following:
 
 - Tuples and tuple patterns.
 
@@ -66,7 +67,7 @@ This proposal adds support for trailing commas in comma-separated lists when the
     ) = velocity
     ```
 
-- Parameter and argument lists of initializers, functions, enum associated values, expression macros, attributes, and availability specs.
+- Parameter and argument lists of initializers, functions, enum associated values, expression macros and attributes.
 
     ```swift
     func foo(
@@ -114,10 +115,6 @@ This proposal adds support for trailing commas in comma-separated lists when the
         )
     }
 
-    if #unavailable(
-        iOS 15,
-        watchOS 9,
-    ) { }
     ```
 
 - Subscripts, including key path subscripts.
@@ -139,164 +136,158 @@ This proposal adds support for trailing commas in comma-separated lists when the
     ])
     ```
 
+- Closure capture lists.
+
+    ```swift
+    { [
+        capturedValue1,
+        capturedValue2,
+    ] in
+    }
+    ```
+
+- Generic parameters.
+
+    ```swift
+    struct S<
+        T1,
+        T2,
+        T3,
+    > { }
+    ```
+
+- String interpolation.
+
+    ```swift
+    let s = "\(1, 2,)"
+    ```
+
+## Detailed Design
+
+Trailing commas will be supported in comma-separated lists when symmetric delimiters (including `(...)`, `[...]`, and `<...>`) enable unambiguous parsing.
+
+Note that the requirement for symmetric delimiters means that the following cases will not support trailing comma:
+
 - `if`, `guard` and `while` condition lists.
 
     ```swift
     if
         condition1,
-        condition2,
+        condition2, ❌
     { }
 
     while
         condition1,
-        condition2,
+        condition2, ❌
     { }
 
     guard
         condition1,
-        condition2,
+        condition2, ❌
     else { }
     ```
+    
+- Enum case label lists.
+
+    ```swift
+    enum E {
+      case
+         a,
+         b,
+         c, ❌
+    }
+    ```
 
 - `switch` case labels.
 
     ```swift
     switch number {
         case
             1,
-            2,
+            2, ❌
         :
             ...
         default:
             ..
     }
     ```
-
-- Closure capture lists.
-
-    ```swift
-    { [
-        capturedValue1,
-        capturedValue2,
-    ] in
-    }
-    ```
-
+    
 - Inheritance clauses.
 
     ```swift
     struct S:
         P1,
         P2,
-        P3,
+        P3, ❌
     { }
     ```
 
-- Generic parameters.
-
-    ```swift
-    struct S<
-        T1,
-        T2,
-        T3,
-    > { }
-    ```
-
 - Generic `where` clauses.
 
     ```swift
     struct S<
         T1,
         T2,
-        T3
+        T3,
     > where
         T1: P1,
-        T2: P2,
+        T2: P2, ❌
     { }
     ```
 
-- String interpolation
-
-    ```swift
-    let s = "\(1, 2,)"
-    ```
-
-## Detailed Design
-
-Trailing commas will be supported in comma-separated lists whenever there is a terminator clear enough that the parser can determine the end of the list. The terminator can be the symbols like `)`, `]`, `>`, `{` and `:`, a keyword like `where` or a pattern code like the body of a `if`, `guard` and `while` statement.
-
-Note that the requirement for a terminator means that the following cases will not support trailing comma:
-
-Enum case label lists:
+Trailing commas will be allowed in single-element lists but not in zero-element lists, since the trailing comma is actually attached to the last element. 
+Supporting a zero-element list would require supporting _leading_ commas, which isn't what this proposal is about.
 
 ```swift
-enum E {
-  case
-     a,
-     b,
-     c, // ❌ Expected identifier after comma in enum 'case' declaration
-}
-```
-
-Inheritance clauses for associated types in a protocol declaration:
-
-```swift
-protocol Foo {
-  associatedtype T:
-      P1,
-      P2, // ❌ Expected type
-}
+(1,) // OK
+(,) ❌ expected value in tuple
 ```
 
-Generic `where` clauses for initializers and functions in a protocol declaration:
 
-```swift
-protocol Foo {
-  func f<T1, T2>(a: T1, b: T2) where
-      T1: P1,
-      T2: P2, // ❌ Expected type
-}
-```
+## Source compatibility
 
-Trailing commas will be allowed in single-element lists but not in zero-element lists, since the trailing comma is actually attached to the last element. Supporting a zero-element list would require supporting _leading_ commas, which isn't what this proposal is about.
+This is a purely additive change with no source compatibility impact.
 
-```swift
-(1,) // OK
-(,) // ❌ expected value in tuple
-```
+## Alternatives considered
 
+### Allow trailing comma in all comma-separated lists
 
-## Source compatibility
+Comma-separated lists that are not symmetrically delimited could also benefit from trailing comma support; for example, condition lists, in which reordering is fairly common. 
+However, these lists currently rely on the comma after the penultimate element to determine that what comes next is the last element, and some of them present challenges if relying on opening/closing delimiters instead.
 
-Although this change won't impact existing valid code it will change how some invalid code is parsed. Consider the following:
+At first sight, `{` may seem a reasonable closing delimiter for `if` and `while` condition lists, but conditions can have a `{` themselves.
 
 ```swift
 if
-  condition1,
-  condition2,
-{ // ❌ Function produces expected type 'Bool'; did you mean to call it with '()'?
-  return true
-}
-
-{ print("something") }
+    condition1,
+    condition2,
+    { true }(),
+{ }
 ```
 
-Currently the parser uses the last comma to determine that whatever follows is the last condition, so `{ return true }` is a condition and `{ print("something") }` is the `if` body.
+This particular case can be handled but, given how complex conditions can be, it's hard to conclude that there's absolutely no corner case where ambiguity can arise in currently valid code.
 
-With trailing comma support, the parser will terminate the condition list before the first block that is a valid `if` body, so `{ return true }` will be parsed as the `if` body and `{ print("something") }` will be parsed as an unused closure expression.
+Inheritance lists and generic `where` clauses can appear in protocol definitons where there's no clear delimiter, making it harder to disambiguate where the list ends.
 
 ```swift
-if
-  condition1,
-  condition2,
-{
-  return true
+protocol Foo {
+  associatedtype T:
+      P1,
+      P2, ❌ Expected type
+  ...
 }
+```
 
-{ print("something") } // ❌ Closure expression is unused
+```swift
+protocol Foo {
+  associatedtype T:
+      P1,
+      P2, ❌ Expected type
+  ...
+}
 ```
 
-## Alternatives considered
+Although some comma-separated lists without symmetric delimiters may have a clear terminator in some cases, this proposal restricts trailing comma support to symmetrically delimited ones where it's clear that the presence of a trailing comma will not cause parsing ambiguity.
 
 ### Eliding commas
 
@@ -312,3 +303,11 @@ print(
 This was even [proposed](https://forums.swift.org/t/se-0257-eliding-commas-from-multiline-expression-lists/22889/188) and returned for revision back in 2019.
 
 The two approaches are not mutually exclusive. There remain unresolved questions about how the language can accommodate elided commas, and adopting this proposal does not prevent that approach from being considered in the future.
+
+## Revision History
+
+- Update to address acceptance decision of restricting trailing comma to lists with symmetric delimiters.
+
+## Acknowledgments
+
+Thanks to Alex Hoppen, Xiaodi Wu and others for their help on the proposal text and implementation.