[Syntax] Add support for compound name in expressions (#13630)

Author: rintaro

lib/Parse/ParseExpr.cpp

@@ -2064,12 +2064,16 @@ DeclName Parser::parseUnqualifiedDeclName(bool afterDot,
     return baseName;
   }
 
+
   // If the next token is a ')' then we have a 0-arg compound name. This is
   // explicitly differentiated from "simple" (non-compound) name in DeclName.
   // Unfortunately only some places in the grammar are ok with accepting this
   // kind of name; in other places it's ambiguous with trailing calls.
   if (allowZeroArgCompoundNames && peekToken().is(tok::r_paren)) {
+    SyntaxParsingContext ArgsCtxt(SyntaxContext, SyntaxKind::DeclNameArguments);
     consumeToken(tok::l_paren);
+    if (SyntaxContext->isEnabled())
+      SyntaxContext->addSyntax(SyntaxFactory::makeBlankDeclNameArgumentList());
     consumeToken(tok::r_paren);
     loc = DeclNameLoc(baseNameLoc);
     SmallVector<Identifier, 2> argumentLabels;
@@ -2084,26 +2088,21 @@ DeclName Parser::parseUnqualifiedDeclName(bool afterDot,
     return baseName;
   }
 
-  // TODO: Support compound name in libSyntax.
-
   // Try to parse a compound name.
+  SyntaxParsingContext ArgsCtxt(SyntaxContext, SyntaxKind::DeclNameArguments);
   BacktrackingScope backtrack(*this);
 
   SmallVector<Identifier, 2> argumentLabels;
   SmallVector<SourceLoc, 2> argumentLabelLocs;
   SourceLoc lparenLoc = consumeToken(tok::l_paren);
   SourceLoc rparenLoc;
-  while (true) {
-    // Terminate at ')'.
-    if (Tok.is(tok::r_paren)) {
-      rparenLoc = consumeToken(tok::r_paren);
-      break;
-    }
+  while (Tok.isNot(tok::r_paren)) {
+    SyntaxParsingContext ArgCtxt(SyntaxContext, SyntaxKind::DeclNameArgument);
 
     // If we see a ':', the user forgot the '_';
     if (Tok.is(tok::colon)) {
       diagnose(Tok, diag::empty_arg_label_underscore)
-        .fixItInsert(Tok.getLoc(), "_");
+          .fixItInsert(Tok.getLoc(), "_");
       argumentLabels.push_back(Identifier());
       argumentLabelLocs.push_back(consumeToken(tok::colon));
     }
@@ -2120,14 +2119,18 @@ DeclName Parser::parseUnqualifiedDeclName(bool afterDot,
     // This is not a compound name.
     // FIXME: Could recover better if we "know" it's a compound name.
     loc = DeclNameLoc(baseNameLoc);
+    ArgsCtxt.setDiscard();
     return baseName;
   }
+  // We have a compound name. Cancel backtracking and build that name.
+  backtrack.cancelBacktrack();
+
+  ArgsCtxt.collectNodesInPlace(SyntaxKind::DeclNameArgumentList);
+  rparenLoc = consumeToken(tok::r_paren);
 
   assert(!argumentLabels.empty() && "Logic above should prevent this");
   assert(argumentLabels.size() == argumentLabelLocs.size());
 
-  // We have a compound name. Cancel backtracking and build that name.
-  backtrack.cancelBacktrack();
   loc = DeclNameLoc(Context, baseNameLoc, lparenLoc, argumentLabelLocs,
                     rparenLoc);
   return DeclName(Context, baseName, argumentLabels);

lib/Syntax/SyntaxParsingContext.cpp

@@ -107,8 +107,6 @@ void SyntaxParsingContext::createNodeInPlace(SyntaxKind Kind) {
 
   switch (Kind) {
   case SyntaxKind::SuperRefExpr:
-  case SyntaxKind::MemberAccessExpr:
-  case SyntaxKind::ImplicitMemberExpr:
   case SyntaxKind::OptionalChainingExpr:
   case SyntaxKind::ForcedValueExpr:
   case SyntaxKind::PostfixUnaryExpr:
@@ -118,6 +116,8 @@ void SyntaxParsingContext::createNodeInPlace(SyntaxKind Kind) {
     createNodeInPlace(Kind, Pair.first);
     break;
   }
+  case SyntaxKind::MemberAccessExpr:
+  case SyntaxKind::ImplicitMemberExpr:
   case SyntaxKind::SimpleTypeIdentifier:
   case SyntaxKind::MemberTypeIdentifier:
   case SyntaxKind::FunctionCallExpr:

test/Syntax/Outputs/round_trip_parse_gen.swift.withkinds

@@ -218,7 +218,11 @@ func postfix<FunctionSignature><ParameterClause>() </ParameterClause></FunctionS
   foo</IdentifierExpr>[] <ClosureExpr>{}</ClosureExpr></SubscriptExpr><SubscriptExpr><IdentifierExpr>
   foo</IdentifierExpr>[<FunctionCallArgument><IntegerLiteralExpr>1</IntegerLiteralExpr></FunctionCallArgument>] <ClosureExpr>{}</ClosureExpr></SubscriptExpr><SubscriptExpr><SubscriptExpr><IdentifierExpr>
   foo</IdentifierExpr>[<FunctionCallArgument><IntegerLiteralExpr>1</IntegerLiteralExpr></FunctionCallArgument>]</SubscriptExpr>[<FunctionCallArgument><IntegerLiteralExpr>2</IntegerLiteralExpr>,</FunctionCallArgument><FunctionCallArgument>x:<IntegerLiteralExpr>3</IntegerLiteralExpr></FunctionCallArgument>]</SubscriptExpr><FunctionCallExpr><ForcedValueExpr><MemberAccessExpr><PostfixUnaryExpr><OptionalChainingExpr><IdentifierExpr>
-  foo</IdentifierExpr>?</OptionalChainingExpr>++</PostfixUnaryExpr>.bar</MemberAccessExpr>!</ForcedValueExpr>(<FunctionCallArgument><IdentifierExpr>baz</IdentifierExpr></FunctionCallArgument>)</FunctionCallExpr>
+  foo</IdentifierExpr>?</OptionalChainingExpr>++</PostfixUnaryExpr>.bar</MemberAccessExpr>!</ForcedValueExpr>(<FunctionCallArgument><IdentifierExpr>baz</IdentifierExpr></FunctionCallArgument>)</FunctionCallExpr><FunctionCallExpr><IdentifierExpr>
+
+  foo<DeclNameArguments>(<DeclNameArgument>x:</DeclNameArgument><DeclNameArgument>y:</DeclNameArgument>)</DeclNameArguments></IdentifierExpr>()</FunctionCallExpr><SequenceExpr><DiscardAssignmentExpr>
+  _ </DiscardAssignmentExpr><AssignmentExpr>= </AssignmentExpr><ImplicitMemberExpr>.foo<DeclNameArguments>(<DeclNameArgument>x:</DeclNameArgument><DeclNameArgument>y:</DeclNameArgument>)</DeclNameArguments></ImplicitMemberExpr></SequenceExpr><SequenceExpr><DiscardAssignmentExpr>
+  _ </DiscardAssignmentExpr><AssignmentExpr>= </AssignmentExpr><MemberAccessExpr><IdentifierExpr>x</IdentifierExpr>.foo<DeclNameArguments>(<DeclNameArgument>x:</DeclNameArgument><DeclNameArgument>y:</DeclNameArgument>)</DeclNameArguments></MemberAccessExpr></SequenceExpr>
 }</CodeBlock></FunctionDecl><IfConfigDecl>
 
 #if <IdentifierExpr>blah</IdentifierExpr><ElseDirectiveClause>

test/Syntax/round_trip_parse_gen.swift

@@ -219,6 +219,10 @@ func postfix() {
   foo[1] {}
   foo[1][2,x:3]
   foo?++.bar!(baz)
+
+  foo(x:y:)()
+  _ = .foo(x:y:)
+  _ = x.foo(x:y:)
 }
 
 #if blah

utils/gyb_syntax_support/ExprNodes.py

@@ -44,10 +44,29 @@
              Child('Expression', kind='Expr'),
          ]),
 
+    # declname-arguments -> '(' declname-argument-list ')'
+    # declname-argument-list -> declname-argument*
+    # declname-argument -> identifier ':'
+    Node('DeclNameArgument', kind='Syntax',
+         children=[
+             Child('Name', kind='Token'),
+             Child('Colon', kind='ColonToken'),
+         ]),
+    Node('DeclNameArgumentList', kind='SyntaxCollection',
+         element='DeclNameArgument'),
+    Node('DeclNameArguments', kind='Syntax',
+         children=[
+             Child('LeftParen', kind='LeftParenToken'),
+             Child('Arguments', kind='DeclNameArgumentList'),
+             Child('RightParen', kind='RightParenToken'),
+         ]),
+
     # An identifier expression.
     Node('IdentifierExpr', kind='Expr',
          children=[
              Child('Identifier', kind='IdentifierToken'),
+             Child('DeclNameArguments', kind='DeclNameArguments',
+                   is_optional=True),
          ]),
 
     # An 'super' expression.
@@ -166,7 +185,9 @@
     Node('ImplicitMemberExpr', kind='Expr',
          children=[
              Child("Dot", kind='PrefixPeriodToken'),
-             Child("Name", kind='Token')
+             Child("Name", kind='Token'),
+             Child('DeclNameArguments', kind='DeclNameArguments',
+                   is_optional=True),
          ]),
 
     # function-call-argument -> label? ':'? expression ','?
@@ -248,7 +269,9 @@
          children=[
              Child("Base", kind='Expr'),
              Child("Dot", kind='PeriodToken'),
-             Child("Name", kind='Token')
+             Child("Name", kind='Token'),
+             Child('DeclNameArguments', kind='DeclNameArguments',
+                   is_optional=True),
          ]),
 
     # is TypeName