libSyntax: create syntax node for closure capture list. (#13408)

Author: nkcsgexi

lib/Parse/ParseExpr.cpp

@@ -25,6 +25,7 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
+#include "swift/Basic/Defer.h"
 #include "swift/Basic/StringExtras.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/SaveAndRestore.h"
@@ -2375,11 +2376,22 @@ parseClosureSignatureIfPresent(SmallVectorImpl<CaptureListEntry> &captureList,
     return false;
   }
 
-  // At this point, we know we have a closure signature. Parse the capture list
-  // and parameters.
-  if (consumeIf(tok::l_square) &&
-      !consumeIf(tok::r_square)) {
+  if (Tok.is(tok::l_square) && peekToken().is(tok::r_square)) {
+    SyntaxParsingContext CaptureCtx(SyntaxContext,
+                                    SyntaxKind::ClosureCaptureSignature);
+    consumeToken(tok::l_square);
+    consumeToken(tok::r_square);
+  } else if (Tok.is(tok::l_square) && !peekToken().is(tok::r_square)) {
+    SyntaxParsingContext CaptureCtx(SyntaxContext,
+                                    SyntaxKind::ClosureCaptureSignature);
+    consumeToken(tok::l_square);
+    // At this point, we know we have a closure signature. Parse the capture list
+    // and parameters.
+    bool HasNext;
     do {
+      SyntaxParsingContext CapturedItemCtx(SyntaxContext,
+                                           SyntaxKind::ClosureCaptureItem);
+      SWIFT_DEFER { HasNext = consumeIf(tok::comma); };
       // Check for the strength specifier: "weak", "unowned", or
       // "unowned(safe/unsafe)".
       SourceLoc loc;
@@ -2419,6 +2431,9 @@ parseClosureSignatureIfPresent(SmallVectorImpl<CaptureListEntry> &captureList,
         continue;
       }
 
+      // Squash all tokens, if any, as the specifier of the captured item.
+      CapturedItemCtx.collectNodesInPlace(SyntaxKind::TokenList);
+
       // The thing being capture specified is an identifier, or as an identifier
       // followed by an expression.
       Expr *initializer;
@@ -2472,8 +2487,9 @@ parseClosureSignatureIfPresent(SmallVectorImpl<CaptureListEntry> &captureList,
                                              CurDeclContext);
 
       captureList.push_back(CaptureListEntry(VD, PBD));
-    } while (consumeIf(tok::comma));
+    } while (HasNext);
 
+    SyntaxContext->collectNodesInPlace(SyntaxKind::ClosureCaptureItemList);
     // The capture list needs to be closed off with a ']'.
     if (!consumeIf(tok::r_square)) {
       diagnose(Tok, diag::expected_capture_list_end_rsquare);

test/Syntax/Outputs/round_trip_parse_gen.swift.withkinds

@@ -126,4 +126,13 @@ func tryfoo<FunctionSignature>() </FunctionSignature><CodeBlock>{<TryExpr>
   try! <IdentifierExpr>foo</IdentifierExpr>()</TryExpr><TryExpr>
   try? <IdentifierExpr>foo</IdentifierExpr>()</TryExpr><TryExpr>
   try! <MemberAccessExpr><IdentifierExpr>foo</IdentifierExpr>().bar</MemberAccessExpr>().foo().bar()</TryExpr>
+}</CodeBlock></FunctionDecl><FunctionDecl>
+
+func closure<FunctionSignature>() </FunctionSignature><CodeBlock>{
+  {<ClosureCaptureSignature>[<ClosureCaptureItem>weak <IdentifierExpr>a</IdentifierExpr>,</ClosureCaptureItem><ClosureCaptureItem>
+    unowned(safe) self,</ClosureCaptureItem><ClosureCaptureItem>
+    b = <IntegerLiteralExpr>3</IntegerLiteralExpr>,</ClosureCaptureItem><ClosureCaptureItem>
+    unowned(unsafe) c = <MemberAccessExpr><IdentifierExpr>foo</IdentifierExpr>().bar</MemberAccessExpr></ClosureCaptureItem>] </ClosureCaptureSignature>in
+  }
+  {<ClosureCaptureSignature>[] </ClosureCaptureSignature>in }
 }</CodeBlock></FunctionDecl>

test/Syntax/round_trip_parse_gen.swift

@@ -127,3 +127,12 @@ func tryfoo() {
   try? foo()
   try! foo().bar().foo().bar()
 }
+
+func closure() {
+  {[weak a,
+    unowned(safe) self,
+    b = 3,
+    unowned(unsafe) c = foo().bar] in
+  }
+  {[] in }
+}

utils/gyb_syntax_support/ExprNodes.py

@@ -263,4 +263,23 @@
          children=[
              Child('Type', kind='Type'),
          ]),
+
+    Node('ClosureCaptureItem', kind='Syntax',
+         children=[
+             Child("Specifier", kind='TokenList', is_optional=True),
+             Child("Name", kind='IdentifierToken', is_optional=True),
+             Child('AssignToken', kind='EqualToken', is_optional=True),
+             Child("Expression", kind='Expr'),
+             Child('TrailingComma', kind='CommaToken', is_optional=True),
+         ]),
+
+    Node('ClosureCaptureItemList', kind='SyntaxCollection',
+         element='ClosureCaptureItem'),
+
+    Node('ClosureCaptureSignature', kind='Syntax',
+         children=[
+             Child('LeftSquare', kind='LeftSquareToken'),
+             Child('Items', kind='ClosureCaptureItemList', is_optional=True),
+             Child('RightSquare', kind='RightSquareToken'),
+         ]),
 ]