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)]),

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,28 @@ extension Parser {
           let specifier = self.parseClosureCaptureSpecifiers()
 
           // The thing being capture specified is an identifier, or as an identifier
-          // followed by an expression.
+          // followed by an initializer clause.
           let unexpectedBeforeName: RawUnexpectedNodesSyntax?
-          let name: RawTokenSyntax?
-          let unexpectedBeforeEqual: RawUnexpectedNodesSyntax?
-          let equal: RawTokenSyntax?
-          let expression: RawExprSyntax
+          let name: RawTokenSyntax
+          let initializer: RawInitializerClauseSyntax?
           if self.peek(isAt: .equal) {
-            // The name is a new declaration.
+            // The name is a new declaration with
+            // initializer clause.
             (unexpectedBeforeName, name) = self.expect(
               .identifier,
               TokenSpec(.self, remapping: .identifier),
               default: .identifier
             )
-            (unexpectedBeforeEqual, equal) = self.expect(.equal)
-            expression = self.parseExpression(flavor: .basic, pattern: .none)
+            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.
+            (unexpectedBeforeName, name) = self.expect(
+              .identifier,
+              TokenSpec(.self),
+              default: .identifier
+            )
+            initializer = nil
           }
 
           keepGoing = self.consume(if: .comma)
@@ -1735,11 +1734,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/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:

Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift

@@ -1167,73 +1167,6 @@ extension ClassDeclSyntax {
   }
 }
 
-extension ClosureCaptureSyntax {
-  @available(*, deprecated, renamed: "unexpectedBetweenNameAndEqual")
-  public var unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? {
-    get {
-      return unexpectedBetweenNameAndEqual
-    }
-    set {
-      unexpectedBetweenNameAndEqual = newValue
-    }
-  }
-
-  @available(*, deprecated, renamed: "equal")
-  public var assignToken: TokenSyntax? {
-    get {
-      return equal
-    }
-    set {
-      equal = newValue
-    }
-  }
-
-  @available(*, deprecated, renamed: "unexpectedBetweenEqualAndExpression")
-  public var unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? {
-    get {
-      return unexpectedBetweenEqualAndExpression
-    }
-    set {
-      unexpectedBetweenEqualAndExpression = newValue
-    }
-  }
-
-  @available(*, deprecated, renamed: "ClosureCaptureSyntax(leadingTrivia:_:specifier:_:name:_:equal:_:expression:_: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, 
-        unexpectedBetweenNameAndAssignToken, 
-        equal: assignToken, 
-        unexpectedBetweenAssignTokenAndExpression, 
-        expression: expression, 
-        unexpectedBetweenExpressionAndTrailingComma, 
-        trailingComma: trailingComma, 
-        unexpectedAfterTrailingComma, 
-        trailingTrivia: trailingTrivia
-      )
-  }
-}
-
 extension ClosureParameterClauseSyntax {
   @available(*, deprecated, renamed: "unexpectedBetweenLeftParenAndParameters")
   public var unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? {

Sources/SwiftSyntax/generated/raw/RawSyntaxNodesC.swift

@@ -935,30 +935,26 @@ public struct RawClosureCaptureSyntax: RawSyntaxNodeProtocol {
       _ unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? = nil, 
       specifier: RawClosureCaptureSpecifierSyntax?, 
       _ unexpectedBetweenSpecifierAndName: RawUnexpectedNodesSyntax? = nil, 
-      name: RawTokenSyntax?, 
-      _ unexpectedBetweenNameAndEqual: RawUnexpectedNodesSyntax? = nil, 
-      equal: RawTokenSyntax?, 
-      _ unexpectedBetweenEqualAndExpression: RawUnexpectedNodesSyntax? = nil, 
-      expression: RawExprSyntax, 
-      _ unexpectedBetweenExpressionAndTrailingComma: RawUnexpectedNodesSyntax? = nil, 
+      name: RawTokenSyntax, 
+      _ unexpectedBetweenNameAndInitializer: RawUnexpectedNodesSyntax? = nil, 
+      initializer: RawInitializerClauseSyntax?, 
+      _ unexpectedBetweenInitializerAndTrailingComma: RawUnexpectedNodesSyntax? = nil, 
       trailingComma: RawTokenSyntax?, 
       _ unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? = nil, 
       arena: __shared SyntaxArena
     ) {
     let raw = RawSyntax.makeLayout(
-      kind: .closureCapture, uninitializedCount: 11, arena: arena) { layout in
+      kind: .closureCapture, uninitializedCount: 9, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeSpecifier?.raw
       layout[1] = specifier?.raw
       layout[2] = unexpectedBetweenSpecifierAndName?.raw
-      layout[3] = name?.raw
-      layout[4] = unexpectedBetweenNameAndEqual?.raw
-      layout[5] = equal?.raw
-      layout[6] = unexpectedBetweenEqualAndExpression?.raw
-      layout[7] = expression.raw
-      layout[8] = unexpectedBetweenExpressionAndTrailingComma?.raw
-      layout[9] = trailingComma?.raw
-      layout[10] = unexpectedAfterTrailingComma?.raw
+      layout[3] = name.raw
+      layout[4] = unexpectedBetweenNameAndInitializer?.raw
+      layout[5] = initializer?.raw
+      layout[6] = unexpectedBetweenInitializerAndTrailingComma?.raw
+      layout[7] = trailingComma?.raw
+      layout[8] = unexpectedAfterTrailingComma?.raw
     }
     self.init(unchecked: raw)
   }
@@ -975,36 +971,28 @@ public struct RawClosureCaptureSyntax: RawSyntaxNodeProtocol {
     layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
-  public var name: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw:))
+  public var name: RawTokenSyntax {
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
 
-  public var unexpectedBetweenNameAndEqual: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenNameAndInitializer: RawUnexpectedNodesSyntax? {
     layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
-  public var equal: RawTokenSyntax? {
-    layoutView.children[5].map(RawTokenSyntax.init(raw:))
+  public var initializer: RawInitializerClauseSyntax? {
+    layoutView.children[5].map(RawInitializerClauseSyntax.init(raw:))
   }
 
-  public var unexpectedBetweenEqualAndExpression: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenInitializerAndTrailingComma: RawUnexpectedNodesSyntax? {
     layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 
-  public var expression: RawExprSyntax {
-    layoutView.children[7].map(RawExprSyntax.init(raw:))!
-  }
-
-  public var unexpectedBetweenExpressionAndTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-
   public var trailingComma: RawTokenSyntax? {
-    layoutView.children[9].map(RawTokenSyntax.init(raw:))
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
 
   public var unexpectedAfterTrailingComma: RawUnexpectedNodesSyntax? {
-    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -563,18 +563,16 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.rightParen)]))
     assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))
   case .closureCapture:
-    assert(layout.count == 11)
+    assert(layout.count == 9)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawClosureCaptureSpecifierSyntax?.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.identifier)]))
+    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)]))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.equal)]))
+    assertNoError(kind, 5, verify(layout[5], as: RawInitializerClauseSyntax?.self))
     assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 7, verify(layout[7], as: RawExprSyntax.self))
+    assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)]))
     assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 9, verify(layout[9], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)]))
-    assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self))
   case .closureExpr:
     assert(layout.count == 9)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))