Merge pull request #2763 from MAJKFL/closure-capture-syntax-node-update

Replace expression in `ClosureCaptureSyntax` with initializer clause

Author: ahoppen

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), .keyword(.self)])
       ),
       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)]),

CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift

@@ -482,22 +482,22 @@ class ValidateSyntaxNodes: XCTestCase {
         ValidationFailure(
           node: .enumCaseElement,
           message:
-            "child 'rawValue' is named inconsistently with 'MatchingPatternConditionSyntax.initializer', which has the same type ('InitializerClauseSyntax')"
+            "child 'rawValue' is named inconsistently with 'ClosureCaptureSyntax.initializer', which has the same type ('InitializerClauseSyntax')"
         ),
         ValidationFailure(
           node: .enumCaseParameter,
           message:
-            "child 'defaultValue' is named inconsistently with 'MatchingPatternConditionSyntax.initializer', which has the same type ('InitializerClauseSyntax')"
+            "child 'defaultValue' is named inconsistently with 'ClosureCaptureSyntax.initializer', which has the same type ('InitializerClauseSyntax')"
         ),
         ValidationFailure(
           node: .functionParameter,
           message:
-            "child 'defaultValue' is named inconsistently with 'MatchingPatternConditionSyntax.initializer', which has the same type ('InitializerClauseSyntax')"
+            "child 'defaultValue' is named inconsistently with 'ClosureCaptureSyntax.initializer', which has the same type ('InitializerClauseSyntax')"
         ),
         ValidationFailure(
           node: .macroDecl,
           message:
-            "child 'definition' is named inconsistently with 'MatchingPatternConditionSyntax.initializer', which has the same type ('InitializerClauseSyntax')"
+            "child 'definition' is named inconsistently with 'ClosureCaptureSyntax.initializer', which has the same type ('InitializerClauseSyntax')"
         ),
         // MARK: Miscellaneous
         ValidationFailure(

Release Notes/601.md

@@ -31,20 +31,28 @@
   - 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
-  
+
 - `FixIt.Change` gained a new case `replaceChild(data:)`.
   - Description: The new case covers the replacement of a child node with another node.
   - Issue: https://github.com/swiftlang/swift-syntax/issues/2205
   - Pull Request: https://github.com/swiftlang/swift-syntax/pull/2758
   - Migration steps: In exhaustive switches over `FixIt.Change`, cover the new case.
 
+- `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
 
 - *Affected API or two word description*

Sources/SwiftLexicalLookup/IdentifiableSyntax.swift

@@ -33,12 +33,7 @@ import SwiftSyntax
 
 @_spi(Experimental) 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/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -560,6 +560,58 @@ extension ClosureCaptureSpecifierSyntax {
   }
 }
 
+extension ClosureCaptureSyntax {
+  @_spi(Diagnostics)
+  public enum NameOptions: TokenSpecSet {
+    case identifier
+    case `self`
+    
+    init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.identifier):
+        self = .identifier
+      case TokenSpec(.self):
+        self = .self
+      default:
+        return nil
+      }
+    }
+    
+    public init?(token: TokenSyntax) {
+      switch token {
+      case TokenSpec(.identifier):
+        self = .identifier
+      case TokenSpec(.self):
+        self = .self
+      default:
+        return nil
+      }
+    }
+    
+    var spec: TokenSpec {
+      switch self {
+      case .identifier:
+        return .identifier
+      case .self:
+        return .keyword(.self)
+      }
+    }
+    
+    /// Returns a token that satisfies the `TokenSpec` of this case.
+    ///
+    /// If the token kind of this spec has variable text, e.g. for an identifier, this returns a token with empty text.
+    @_spi(Diagnostics)
+    public var tokenSyntax: TokenSyntax {
+      switch self {
+      case .identifier:
+        return .identifier("")
+      case .self:
+        return .keyword(.self)
+      }
+    }
+  }
+}
+
 extension ClosureParameterSyntax {
   @_spi(Diagnostics)
   public enum FirstNameOptions: TokenSpecSet {

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.