Replace expression in ClosureCaptureSyntax with initializer clause

CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift

@@ -341,19 +341,13 @@ public let EXPR_NODES: [Node] = [
       ),
       Child(
         name: "name",
-        kind: .token(choices: [.token(.identifier)]),
-        isOptional: true
+        kind: .token(choices: [.token(.identifier)])
       ),
       Child(
-        name: "equal",
-        deprecatedName: "assignToken",
-        kind: .token(choices: [.token(.equal)]),
+        name: "initializer",
+        kind: .node(kind: .initializerClause),
         isOptional: true
       ),
-      Child(
-        name: "expression",
-        kind: .node(kind: .expr)
-      ),
       Child(
         name: "trailingComma",
         kind: .token(choices: [.token(.comma)]),

Release Notes/601.md

@@ -27,13 +27,21 @@
   - Description: `IncrementalEdit` is being dropped for `SourceEdit`. `SourceEdit` has deprecated compatibility layers to make it API-compatible with `IncrementalEdit`
   - Issue: https://github.com/apple/swift-syntax/issues/2532
   - Pull request: https://github.com/apple/swift-syntax/pull/2604
+
+- `ClosureCaptureSyntax.init(leadingTrivia:specifier:name:equal:expression:trailingComma:trailingTrivia:)` deprecated in favor of a new `ClosureCaptureSyntax.init(leadingTrivia:_:specifier:_:name:_:initializer:_:trailingComma:_:trailingTrivia:)` initializer.
+  - Description: `ClosureCaptureSyntax` now has an `initializer` property instead of `equal` and `expression`. Additionally, the `name` property is no longer optional.
+  - Pull request: https://github.com/swiftlang/swift-syntax/pull/2763 
 
 ## API-Incompatible Changes
 
 - Moved `Radix` and `IntegerLiteralExprSyntax.radix` from `SwiftRefactor` to `SwiftSyntax`.
   - Description: Allows retrieving the radix value from the `literal.text`.
   - Issue: https://github.com/apple/swift-syntax/issues/405
   - Pull Request: https://github.com/apple/swift-syntax/pull/2605
+
+- `ClosureCaptureSyntax.name` is no longer optional.
+  - Description: Due to the new `ClosureCaptureSyntax` node structure, `name` property is non-optional.
+  - Pull request: https://github.com/swiftlang/swift-syntax/pull/2763 
 
 ## Template
 

Sources/SwiftLexicalLookup/IdentifiableSyntax.swift

@@ -33,11 +33,6 @@ extension ClosureShorthandParameterSyntax: IdentifiableSyntax {
 
 extension ClosureCaptureSyntax: IdentifiableSyntax {
   @_spi(Experimental) public var identifier: TokenSyntax {
-    /* Doesn't work with closures like:
-     _ = { [y=1+2] in
-       print(y)
-     }
-     */
-    expression.as(DeclReferenceExprSyntax.self)!.baseName
+    name
   }
 }

Sources/SwiftParser/Expressions.swift

@@ -1615,7 +1615,7 @@ extension Parser {
 }
 
 extension Parser {
-  mutating func parseDefaultArgument() -> RawInitializerClauseSyntax {
+  mutating func parseInitializerClause() -> RawInitializerClauseSyntax {
     let unexpectedBeforeEq: RawUnexpectedNodesSyntax?
     let eq: RawTokenSyntax
     if let comparison = self.consumeIfContextualPunctuator("==") {
@@ -1704,29 +1704,22 @@ extension Parser {
           let specifier = self.parseClosureCaptureSpecifiers()
 
           // The thing being capture specified is an identifier, or as an identifier
-          // followed by an expression.
-          let unexpectedBeforeName: RawUnexpectedNodesSyntax?
-          let name: RawTokenSyntax?
-          let unexpectedBeforeEqual: RawUnexpectedNodesSyntax?
-          let equal: RawTokenSyntax?
-          let expression: RawExprSyntax
-          if self.peek(isAt: .equal) {
-            // The name is a new declaration.
-            (unexpectedBeforeName, name) = self.expect(
-              .identifier,
-              TokenSpec(.self, remapping: .identifier),
-              default: .identifier
-            )
-            (unexpectedBeforeEqual, equal) = self.expect(.equal)
-            expression = self.parseExpression(flavor: .basic, pattern: .none)
+          // followed by an initializer clause.
+          let (unexpectedBeforeName, name) = self.expect(
+            .identifier,
+            TokenSpec(.self),
+            default: .identifier
+          )
+
+          let initializer: RawInitializerClauseSyntax?
+          if self.at(.equal) {
+            // The name is a new declaration with
+            // initializer clause.
+            initializer = self.parseInitializerClause()
           } else {
-            // This is the simple case - the identifier is both the name and
-            // the expression to capture.
-            unexpectedBeforeName = nil
-            name = nil
-            unexpectedBeforeEqual = nil
-            equal = nil
-            expression = RawExprSyntax(self.parseIdentifierExpression(flavor: .basic))
+            // This is the simple case - the identifier is the name and
+            // the initializer clause is empty.
+            initializer = nil
           }
 
           keepGoing = self.consume(if: .comma)
@@ -1735,11 +1728,9 @@ extension Parser {
               specifier: specifier,
               unexpectedBeforeName,
               name: name,
-              unexpectedBeforeEqual,
-              equal: equal,
-              expression: expression,
+              initializer: initializer,
               trailingComma: keepGoing,
-              arena: self.arena
+              arena: arena
             )
           )
         } while keepGoing != nil && self.hasProgressed(&loopProgress)

Sources/SwiftParser/Parameters.swift

@@ -129,7 +129,7 @@ extension Parser {
 
     let defaultValue: RawInitializerClauseSyntax?
     if self.at(.equal) || self.atContextualPunctuator("==") {
-      defaultValue = self.parseDefaultArgument()
+      defaultValue = self.parseInitializerClause()
     } else {
       defaultValue = nil
     }
@@ -234,7 +234,7 @@ extension Parser {
 
     let defaultValue: RawInitializerClauseSyntax?
     if self.at(.equal) || self.atContextualPunctuator("==") {
-      defaultValue = self.parseDefaultArgument()
+      defaultValue = self.parseInitializerClause()
     } else {
       defaultValue = nil
     }

Sources/SwiftSyntax/Convenience.swift

@@ -10,33 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-extension ClosureCaptureSyntax {
-
-  /// Creates a ``ClosureCaptureSyntax`` with a `name`, and automatically adds an `equal` token to it since the name is non-optional.
-  ///
-  /// - SeeAlso: ``ClosureCaptureSyntax/init(leadingTrivia:_:specifier:_:name:_:equal:_:expression:_:trailingComma:_:trailingTrivia:)``.
-  ///
-  public init(
-    leadingTrivia: Trivia? = nil,
-    specifier: ClosureCaptureSpecifierSyntax? = nil,
-    name: TokenSyntax,
-    equal: TokenSyntax = TokenSyntax.equalToken(),
-    expression: some ExprSyntaxProtocol,
-    trailingComma: TokenSyntax? = nil,
-    trailingTrivia: Trivia? = nil
-  ) {
-    self.init(
-      leadingTrivia: leadingTrivia,
-      specifier: specifier,
-      name: name as TokenSyntax?,
-      equal: equal,
-      expression: expression,
-      trailingComma: trailingComma,
-      trailingTrivia: trailingTrivia
-    )
-  }
-}
-
 extension EnumCaseParameterSyntax {
 
   /// Creates an ``EnumCaseParameterSyntax`` with a `firstName`, and automatically adds a `colon` to it.

Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift

@@ -144,6 +144,197 @@ extension DeclGroupSyntax {
   }
 }
 
+extension ClosureCaptureSyntax {
+  @available(*, deprecated, renamed: "unexpectedBetweenNameAndInitializer")
+  public var unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBetweenNameAndInitializer
+    }
+    set {
+      unexpectedBetweenNameAndInitializer = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "initializer.equal")
+  public var assignToken: TokenSyntax? {
+    get {
+      return initializer?.equal
+    }
+    set {
+      initializer?.equal = newValue ?? .equalToken(presence: .missing)
+    }
+  }
+
+  @available(*, deprecated, renamed: "initializer.unexpectedBetweenEqualAndValue")
+  public var unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? {
+    get {
+      return initializer?.unexpectedBetweenEqualAndValue
+    }
+    set {
+      initializer?.unexpectedBetweenEqualAndValue = newValue
+    }
+  }
+
+  @available(
+    *,
+    deprecated,
+    renamed: "ClosureCaptureSyntax(leadingTrivia:_:specifier:_:name:_:initializer:_:trailingComma:_:trailingTrivia:)"
+  )
+  @_disfavoredOverload
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil,
+    specifier: ClosureCaptureSpecifierSyntax? = nil,
+    _ unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax? = nil,
+    _ unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? = nil,
+    assignToken: TokenSyntax? = nil,
+    _ unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? = nil,
+    expression: some ExprSyntaxProtocol,
+    _ unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil,
+    trailingComma: TokenSyntax? = nil,
+    _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeSpecifier,
+      specifier: specifier,
+      unexpectedBetweenSpecifierAndName,
+      name: name ?? .identifier("", presence: .missing),
+      unexpectedBetweenNameAndAssignToken,
+      initializer: InitializerClauseSyntax(
+        equal: assignToken ?? .equalToken(presence: .missing),
+        unexpectedBetweenAssignTokenAndExpression,
+        value: expression
+      ),
+      unexpectedBetweenExpressionAndTrailingComma,
+      trailingComma: trailingComma,
+      unexpectedAfterTrailingComma,
+      trailingTrivia: trailingTrivia
+    )
+  }
+
+  /// Creates a ``ClosureCaptureSyntax`` with a `name`, and automatically adds an `equal` token to it since the name is non-optional.
+  ///
+  /// - SeeAlso: ``ClosureCaptureSyntax/init(leadingTrivia:_:specifier:_:name:_:initializer:_:trailingComma:_:trailingTrivia:)``.
+  ///
+  @available(
+    *,
+    deprecated,
+    message: "Use 'init(leadingTrivia:_:specifier:_:name:_:initializer:_:trailingComma:_:trailingTrivia:)' instead"
+  )
+  public init(
+    leadingTrivia: Trivia? = nil,
+    specifier: ClosureCaptureSpecifierSyntax? = nil,
+    name: TokenSyntax,
+    equal: TokenSyntax = TokenSyntax.equalToken(),
+    expression: some ExprSyntaxProtocol,
+    trailingComma: TokenSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      specifier: specifier,
+      name: name,
+      initializer: InitializerClauseSyntax(equal: equal, value: expression),
+      trailingComma: trailingComma,
+      trailingTrivia: trailingTrivia
+    )
+  }
+
+  @available(*, deprecated, renamed: "unexpectedBetweenNameAndInitializer")
+  public var unexpectedBetweenNameAndEqual: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBetweenNameAndInitializer
+    }
+    set {
+      unexpectedBetweenNameAndInitializer = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "initializer.equal")
+  public var equal: TokenSyntax? {
+    get {
+      return initializer?.equal
+    }
+    set {
+      initializer?.equal = newValue ?? .equalToken(presence: .missing)
+    }
+  }
+
+  @available(*, deprecated, renamed: "initializer.unexpectedBetweenEqualAndValue")
+  public var unexpectedBetweenEqualAndExpression: UnexpectedNodesSyntax? {
+    get {
+      return initializer?.unexpectedBetweenEqualAndValue
+    }
+    set {
+      initializer?.unexpectedBetweenEqualAndValue = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "initializer.value")
+  public var expression: ExprSyntax {
+    get {
+      return initializer?.value ?? ExprSyntax(MissingExprSyntax())
+    }
+    set(value) {
+      initializer?.value = value
+    }
+  }
+
+  @available(*, deprecated, renamed: "unexpectedBetweenInitializerAndTrailingComma")
+  public var unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBetweenInitializerAndTrailingComma
+    }
+    set(value) {
+      unexpectedBetweenInitializerAndTrailingComma = value
+    }
+  }
+
+  @available(
+    *,
+    deprecated,
+    renamed: "ClosureCaptureSyntax(leadingTrivia:_:specifier:_:name:_:initializer:_:trailingComma:_:trailingTrivia:)"
+  )
+  @_disfavoredOverload
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil,
+    specifier: ClosureCaptureSpecifierSyntax? = nil,
+    _ unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax? = nil,
+    _ unexpectedBetweenNameAndEqual: UnexpectedNodesSyntax? = nil,
+    equal: TokenSyntax? = nil,
+    _ unexpectedBetweenEqualAndExpression: UnexpectedNodesSyntax? = nil,
+    expression: some ExprSyntaxProtocol,
+    _ unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil,
+    trailingComma: TokenSyntax? = nil,
+    _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeSpecifier,
+      specifier: specifier,
+      unexpectedBetweenSpecifierAndName,
+      name: name ?? .identifier("", presence: .missing),
+      unexpectedBetweenNameAndEqual,
+      initializer: InitializerClauseSyntax(
+        equal: equal ?? .equalToken(presence: .missing),
+        unexpectedBetweenEqualAndExpression,
+        value: expression
+      ),
+      unexpectedBetweenExpressionAndTrailingComma,
+      trailingComma: trailingComma,
+      unexpectedAfterTrailingComma,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
 extension EffectSpecifiersSyntax {
   @available(*, deprecated, renamed: "unexpectedBetweenAsyncSpecifierAndThrowsClause")
   public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? {

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -499,16 +499,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenSpecifierAndName"
   case \ClosureCaptureSyntax.name:
     return "name"
-  case \ClosureCaptureSyntax.unexpectedBetweenNameAndEqual:
-    return "unexpectedBetweenNameAndEqual"
-  case \ClosureCaptureSyntax.equal:
-    return "equal"
-  case \ClosureCaptureSyntax.unexpectedBetweenEqualAndExpression:
-    return "unexpectedBetweenEqualAndExpression"
-  case \ClosureCaptureSyntax.expression:
-    return "expression"
-  case \ClosureCaptureSyntax.unexpectedBetweenExpressionAndTrailingComma:
-    return "unexpectedBetweenExpressionAndTrailingComma"
+  case \ClosureCaptureSyntax.unexpectedBetweenNameAndInitializer:
+    return "unexpectedBetweenNameAndInitializer"
+  case \ClosureCaptureSyntax.initializer:
+    return "initializer"
+  case \ClosureCaptureSyntax.unexpectedBetweenInitializerAndTrailingComma:
+    return "unexpectedBetweenInitializerAndTrailingComma"
   case \ClosureCaptureSyntax.trailingComma:
     return "trailingComma"
   case \ClosureCaptureSyntax.unexpectedAfterTrailingComma: