[Parser] Adopt ArgumentList

Split up the expr list parsing members such that
there are separate entry points for tuple and
argument list parsing, and start using the argument
list parsing member for call and subscripts.

Author: hamishknight

include/swift/Parse/Parser.h

@@ -1695,24 +1695,32 @@ class Parser {
           SourceLoc &inLoc);
 
   Expr *parseExprAnonClosureArg();
-  ParserResult<Expr> parseExprList(tok LeftTok, tok RightTok,
-                                   syntax::SyntaxKind Kind);
 
-  /// Parse an expression list, keeping all of the pieces separated.
-  ParserStatus parseExprList(tok leftTok, tok rightTok,
-                             bool isPostfix,
-                             bool isExprBasic,
-                             SourceLoc &leftLoc,
-                             SmallVectorImpl<Expr *> &exprs,
-                             SmallVectorImpl<Identifier> &exprLabels,
-                             SmallVectorImpl<SourceLoc> &exprLabelLocs,
-                             SourceLoc &rightLoc,
-                             SmallVectorImpl<TrailingClosure> &trailingClosures,
-                             syntax::SyntaxKind Kind);
+  /// An element of an expression list, which may become e.g a tuple element or
+  /// argument list argument.
+  struct ExprListElt {
+    SourceLoc LabelLoc;
+    Identifier Label;
+    Expr *E;
+  };
 
-  ParserStatus
-  parseTrailingClosures(bool isExprBasic, SourceRange calleeRange,
-                        SmallVectorImpl<TrailingClosure> &closures);
+  /// Parse a tuple or paren expr.
+  ParserResult<Expr> parseTupleOrParenExpr(tok leftTok, tok rightTok);
+
+  /// Parse an argument list.
+  ParserResult<ArgumentList>
+  parseArgumentList(tok leftTok, tok rightTok, bool isExprBasic,
+                    bool allowTrailingClosure = true);
+
+  /// Parse one or more trailing closures after an argument list.
+  ParserStatus parseTrailingClosures(bool isExprBasic, SourceRange calleeRange,
+                                     SmallVectorImpl<Argument> &closures);
+
+  /// Parse an expression list.
+  ParserStatus parseExprList(tok leftTok, tok rightTok, bool isArgumentList,
+                             SourceLoc &leftLoc,
+                             SmallVectorImpl<ExprListElt> &elts,
+                             SourceLoc &rightLoc, SyntaxKind Kind);
 
   /// Parse an object literal.
   ///

lib/Parse/ParseDecl.cpp

@@ -2762,18 +2762,11 @@ ParserResult<CustomAttr> Parser::parseCustomAttribute(
     return ParserResult<CustomAttr>(ParserStatus(type));
   }
 
-  // Parse the optional arguments.
-  SourceLoc lParenLoc, rParenLoc;
-  SmallVector<Expr *, 2> args;
-  SmallVector<Identifier, 2> argLabels;
-  SmallVector<SourceLoc, 2> argLabelLocs;
-  SmallVector<TrailingClosure, 2> trailingClosures;
-  bool hasInitializer = false;
-
   // If we're not in a local context, we'll need a context to parse
   // initializers into (should we have one).  This happens for properties
   // and global variables in libraries.
   ParserStatus status;
+  ArgumentList *argList = nullptr;
   if (Tok.isFollowingLParen() && isCustomAttributeArgument()) {
     if (peekToken().is(tok::code_complete)) {
       consumeToken(tok::l_paren);
@@ -2800,22 +2793,20 @@ ParserResult<CustomAttr> Parser::parseCustomAttribute(
 
         initParser.emplace(*this, initContext);
       }
-      status |= parseExprList(tok::l_paren, tok::r_paren,
-                              /*isPostfix=*/false, /*isExprBasic=*/true,
-                              lParenLoc, args, argLabels, argLabelLocs,
-                              rParenLoc,
-                              trailingClosures,
-                              SyntaxKind::TupleExprElementList);
-      assert(trailingClosures.empty() && "Cannot parse a trailing closure here");
-      hasInitializer = true;
+      auto result = parseArgumentList(tok::l_paren, tok::r_paren,
+                                      /*isExprBasic*/ true,
+                                      /*allowTrailingClosure*/ false);
+      status |= result;
+      argList = result.get();
+      assert(!argList->hasAnyTrailingClosures() &&
+             "Cannot parse a trailing closure here");
     }
   }
 
   // Form the attribute.
   auto *TE = new (Context) TypeExpr(type.get());
-  auto customAttr = CustomAttr::create(Context, atLoc, TE, hasInitializer,
-                                       initContext, lParenLoc, args, argLabels,
-                                       argLabelLocs, rParenLoc);
+  auto *customAttr = CustomAttr::create(Context, atLoc, TE, initContext,
+                                        argList);
   return makeParserResult(status, customAttr);
 }