[SR-12583] Added checks to catch 'foo() {} {}' and 'foo {} () {}'

include/swift/AST/DiagnosticsParse.def

@@ -1189,6 +1189,9 @@ WARNING(trailing_closure_after_newlines,none,
 NOTE(trailing_closure_callee_here,none,
      "callee is here", ())
 
+ERROR(double_trailing_closure,none,
+    "double trailing closures", ())
+
 ERROR(string_literal_no_atsign,none,
       "string literals in Swift are not preceded by an '@' sign", ())
 

lib/Parse/ParseExpr.cpp

@@ -1225,14 +1225,41 @@ Parser::parseExprPostfixSuffix(ParserResult<Expr> Result, bool isExprBasic,
       if (trailingClosures.empty())
         return nullptr;
 
+      // We are creating a call node
+      // with trailing closure
+      // if we are already in a call node with trailing closure we should diagnose
+      // (call_expr
+      //  (call_expr
+      //    (paren_expr trailing-closure))
+      //  (paren_expr trailing-closure))
+      // this catches one problem
+      // let q1 = bar()
+      // {7 * $0}
+      // {5 * $0}
+      // but not the problem where the paren after bar() is
+      //   after the first closure (with 7) instead
+      //  TODO: is there any legitimate case for that parse?
+
       // Trailing closure implicitly forms a call.
+
+      if (!trailingClosures.empty()
+          && Result.get()->getKind() == ExprKind::Call) {
+        auto call = static_cast<CallExpr*>(Result.get());
+        if (call->hasTrailingClosure()) {
+          //diagnose and return bad result
+          diagnose(trailingClosures[0].ClosureExpr->getEndLoc(), diag::double_trailing_closure);
+          break;
+        }
+      }
+
       Result = makeParserResult(
           ParserStatus(Result) | trailingResult,
           CallExpr::create(Context, Result.get(), SourceLoc(), {}, {}, {},
                            SourceLoc(), trailingClosures,
                            /*implicit=*/false));
       SyntaxContext->createNodeInPlace(SyntaxKind::FunctionCallExpr);
 
+      // I think this is intended to handle the double-trailing-closures condition but does not catch it.
       // We only allow a single trailing closure on a call.  This could be
       // generalized in the future, but needs further design.
       if (Tok.is(tok::l_brace))
@@ -1599,6 +1626,7 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
       return makeParserErrorResult(new (Context) ErrorExpr(DotLoc));
     SyntaxContext->createNodeInPlace(SyntaxKind::MemberAccessExpr);
 
+//     () suffix
     // Check for a () suffix, which indicates a call when constructing
     // this member.  Note that this cannot be the start of a new line.
     if (Tok.isFollowingLParen()) {
@@ -3448,7 +3476,24 @@ Parser::parseExprCallSuffix(ParserResult<Expr> fn, bool isExprBasic) {
                                       trailingClosures,
                                       SyntaxKind::TupleExprElementList);
 
+  // check for the pattern:
+  //    let q2 =
+  //      bar {7 * $0} ()
+  //      {5 * $0}
+  //  with the () after the first trailing closure
+
   // Form the call.
+
+  if (!trailingClosures.empty()
+        && fn.get()->getKind() == ExprKind::Call) {
+      auto call = static_cast<CallExpr*>(fn.get());
+      if (call->hasTrailingClosure()) {
+        diagnose(trailingClosures[0].ClosureExpr->getEndLoc(), diag::double_trailing_closure);
+        // return nullptr or error here?
+        return nullptr;
+      }
+  }
+
   return makeParserResult(status | fn,
                           CallExpr::create(Context, fn.get(), lParenLoc, args,
                                            argLabels, argLabelLocs, rParenLoc,

test/Parse/double_trailing_closure.swift

@@ -0,0 +1,19 @@
+// RUN: %target-typecheck-verify-swift
+
+func bar(_ f: @escaping (Int) -> Int) -> ((Int) -> Int) -> Int {
+  let r : ((Int) -> Int) -> Int =
+  {(g: (_ r1 : Int) -> Int) in
+      g(f(2))
+  }
+  return r
+}
+
+// bad 1
+let q1 = bar()
+{7 * $0}
+{5 * $0} // expected-error {{double trailing closures}}
+
+// bad 2 (note that () can't be on its own line
+let q2 =
+bar {7 * $0} ()
+{5 * $0} // expected-error {{double trailing closures}}