Merge pull request #27592 from rintaro/syntaxparse-exprtuple

[SyntaxParse] Parse tuple/paren expression syntax

Author: rintaro

include/swift/AST/DiagnosticsParse.def

@@ -970,6 +970,8 @@ ERROR(expected_expr_throw,PointsToFirstBadToken,
 // Yield Statment
 ERROR(expected_expr_yield,PointsToFirstBadToken,
       "expected expression in 'yield' statement", ())
+ERROR(unexpected_arg_label_yield,none,
+      "unexpected argument label in 'yield' statement", ())
 
 // Defer Statement
 ERROR(expected_lbrace_after_defer,PointsToFirstBadToken,

include/swift/Parse/ASTGen.h

@@ -87,6 +87,7 @@ class ASTGen {
   Expr *generate(const syntax::SuperRefExprSyntax &Expr, const SourceLoc Loc);
   Expr *generate(const syntax::ArrayExprSyntax &Expr, const SourceLoc Loc);
   Expr *generate(const syntax::DictionaryExprSyntax &Expr, const SourceLoc Loc);
+  Expr *generate(const syntax::TupleExprSyntax &E, const SourceLoc Loc);
   Expr *generate(const syntax::EditorPlaceholderExprSyntax &Expr,
                  const SourceLoc Loc);
   Expr *generate(const syntax::SpecializeExprSyntax &Expr, const SourceLoc Loc);
@@ -112,6 +113,12 @@ class ASTGen {
       const Optional<syntax::DeclNameArgumentsSyntax> &args,
       const SourceLoc Loc);
 
+  void generateExprTupleElementList(const syntax::TupleExprElementListSyntax &elements,
+                                    const SourceLoc Loc, bool isForCallArguments,
+                                    SmallVectorImpl<Expr *> &exprs,
+                                    SmallVectorImpl<Identifier> &exprLabels,
+                                    SmallVectorImpl<SourceLoc> &exprLabelLocs);
+
 private:
   void validateCollectionElement(Expr *elementExpr);
 

include/swift/Parse/Parser.h

@@ -1558,8 +1558,11 @@ class Parser {
                                       SourceLoc &inLoc);
 
   Expr *parseExprAnonClosureArg();
-  ParserResult<Expr> parseExprList(tok LeftTok, tok RightTok,
-                                   syntax::SyntaxKind Kind);
+  ParserResult<Expr> parseExprParenOrTuple();
+  ParsedSyntaxResult<ParsedExprSyntax> parseExprTupleSyntax();
+  ParserStatus parseExprTupleElementListSyntax(
+      SmallVectorImpl<ParsedTupleExprElementSyntax> &elements,
+      llvm::function_ref<bool()> isAtCloseTok);
 
   /// Parse an expression list, keeping all of the pieces separated.
   ParserStatus parseExprList(tok leftTok, tok rightTok,
@@ -1570,8 +1573,7 @@ class Parser {
                              SmallVectorImpl<Identifier> &exprLabels,
                              SmallVectorImpl<SourceLoc> &exprLabelLocs,
                              SourceLoc &rightLoc,
-                             Expr *&trailingClosure,
-                             syntax::SyntaxKind Kind);
+                             Expr *&trailingClosure);
 
   ParserResult<Expr> parseTrailingClosure(SourceRange calleeRange);
 

lib/Parse/ASTGen.cpp

@@ -248,6 +248,8 @@ Expr *ASTGen::generate(const ExprSyntax &E, const SourceLoc Loc) {
     result = generate(*arrayExpr, Loc);
   else if (auto dictionaryExpr = E.getAs<DictionaryExprSyntax>())
     result = generate(*dictionaryExpr, Loc);
+  else if (auto tupleExpr = E.getAs<TupleExprSyntax>())
+    result = generate(*tupleExpr, Loc);
   else if (auto integerLiteralExpr = E.getAs<IntegerLiteralExprSyntax>())
     result = generate(*integerLiteralExpr, Loc);
   else if (auto floatLiteralExpr = E.getAs<FloatLiteralExprSyntax>())
@@ -526,6 +528,72 @@ Expr *ASTGen::generate(const DictionaryExprSyntax &E, const SourceLoc Loc) {
                                 RSquareLoc);
 }
 
+Expr *ASTGen::generate(const TupleExprSyntax &E, const SourceLoc Loc) {
+  SmallVector<Expr *, 2> exprs;
+  SmallVector<Identifier, 2> exprLabels;
+  SmallVector<SourceLoc, 2> exprLabelLocs;
+  generateExprTupleElementList(E.getElementList(), Loc,
+  /*isForCallArguments=*/false, exprs, exprLabels,
+                               exprLabelLocs);
+
+  SourceLoc leftLoc = advanceLocBegin(Loc, E.getLeftParen());
+  SourceLoc rightLoc = advanceLocEnd(Loc, E);
+
+  // A tuple with a single, unlabeled element is just parentheses.
+  if (exprs.size() == 1 && exprLabels.empty()) {
+    return new (Context) ParenExpr(leftLoc, exprs[0], rightLoc,
+                                   /*hasTrailingClosure=*/false);
+  }
+
+  return TupleExpr::create(Context, leftLoc, exprs, exprLabels, exprLabelLocs,
+                           rightLoc, /*HasTrailingClosure=*/false,
+                           /*Implicit=*/false);
+}
+
+void ASTGen::generateExprTupleElementList(const TupleExprElementListSyntax &elements,
+                                          const SourceLoc Loc, bool isForCallArguments,
+                                          SmallVectorImpl<Expr *> &exprs,
+                                  SmallVectorImpl<Identifier> &exprLabels,
+                                  SmallVectorImpl<SourceLoc> &exprLabelLocs) {
+  auto isFirst = true;
+  for (auto elem : elements) {
+    auto *subExpr = generate(elem.getExpression(), Loc);
+    if (!subExpr)
+      continue;
+
+    // Handle call arguments specially because it may need argument labels.
+    if (P.CodeCompletion && isForCallArguments && !elem.getLabel())
+      if (auto CCExpr = elem.getExpression().getAs<CodeCompletionExprSyntax>())
+        if (!CCExpr->getBase() && !CCExpr->getPeriodOrParen())
+          P.CodeCompletion->completeCallArg(cast<CodeCompletionExpr>(subExpr),
+                                              isFirst);
+    isFirst = false;
+
+    Identifier fieldName;
+    SourceLoc fieldNameLoc;
+    if (auto label = elem.getLabel()) {
+      fieldNameLoc = advanceLocBegin(Loc, *label);
+      if (label->getTokenKind() == tok::identifier)
+        fieldName = Context.getIdentifier(label->getIdentifierText());
+    }
+
+    // Don't populate label vectors unless we see at least one label.
+    if (!exprLabels.empty()) {
+      exprLabels.push_back(fieldName);
+      exprLabelLocs.push_back(fieldNameLoc);
+    } else if (fieldNameLoc.isValid()) {
+      exprLabels.resize(exprs.size());
+      exprLabelLocs.resize(exprs.size());
+      exprLabels.push_back(fieldName);
+      exprLabelLocs.push_back(fieldNameLoc);
+    }
+    exprs.push_back(subExpr);
+  }
+  assert((exprLabels.size() == 0 || exprs.size() == exprLabels.size()) &&
+         exprLabels.size() == exprLabelLocs.size());
+}
+
+
 Expr *ASTGen::generate(const IntegerLiteralExprSyntax &Expr,
                        const SourceLoc Loc) {
   auto Digits = Expr.getDigits();

lib/Parse/ParseDecl.cpp

@@ -1784,8 +1784,7 @@ ParserStatus Parser::parseDeclAttribute(DeclAttributes &Attributes, SourceLoc At
         status |= parseExprList(tok::l_paren, tok::r_paren,
                                 /*isPostfix=*/false, /*isExprBasic=*/true,
                                 lParenLoc, args, argLabels, argLabelLocs,
-                                rParenLoc, trailingClosure,
-                                SyntaxKind::TupleExprElementList);
+                                rParenLoc, trailingClosure);
         assert(!trailingClosure && "Cannot parse a trailing closure here");
         hasInitializer = true;
       }