Parser: Explicitly ban closures at the beginning of statements.

This already can't happen in most circumstances because of trailing closures, but we didn't explicitly disallow it at the beginning of a BraceStmt or following a statement production. Fixes the parser part of rdar://problem/17850752 (though there's a type checker bug there too).

Swift SVN r21663

Author: jckarter

include/swift/AST/DiagnosticsParse.def

@@ -645,13 +645,17 @@ ERROR(illegal_top_level_expr,stmt_parsing,none,
       "expressions are not allowed at the top level", ())
 ERROR(illegal_semi_stmt,stmt_parsing,none,
       "';' statements are not allowed", ())
+ERROR(statement_begins_with_closure,stmt_parsing,none,
+      "statement cannot begin with a closure expression", ())
 ERROR(statement_same_line_without_semi,stmt_parsing,none,
       "consecutive statements on a line must be separated by ';'", ())
 ERROR(brace_stmt_invalid,stmt_parsing,none,
       "braced block of statements is an unused closure", ())
 ERROR(invalid_label_on_stmt,stmt_parsing,none,
       "labels are only valid on loops and switch statement", ())
 
+NOTE(discard_result_of_closure,stmt_parsing,none,
+     "explicitly discard the result of the closure by assigning to '_'", ())
 
 // Assignment statement
 ERROR(expected_expr_assignment,stmt_parsing,none,

lib/Parse/ParseStmt.cpp

@@ -324,6 +324,14 @@ ParserStatus Parser::parseBraceItems(SmallVectorImpl<ASTNode> &Entries,
       ContextChange CC(*this, TLCD, &State->getTopLevelContext());
       SourceLoc StartLoc = Tok.getLoc();
 
+      // Expressions can't begin with a closure literal at statement position.
+      // This prevents potential ambiguities with trailing closure syntax.
+      if (Tok.is(tok::l_brace)) {
+        diagnose(Tok, diag::statement_begins_with_closure);
+        diagnose(Tok, diag::discard_result_of_closure)
+          .fixItInsert(Tok.getLoc(), "_ = ");
+      }
+
       ParserStatus Status = parseExprOrStmt(Result);
       if (Status.hasCodeCompletion() && isCodeCompletionFirstPass()) {
         consumeTopLevelDecl(BeginParserPosition, TLCD);
@@ -434,6 +442,15 @@ void Parser::parseTopLevelCodeDeclDelayed() {
 
   SourceLoc StartLoc = Tok.getLoc();
   ASTNode Result;
+
+  // Expressions can't begin with a closure literal at statement position. This
+  // prevents potential ambiguities with trailing closure syntax.
+  if (Tok.is(tok::l_brace)) {
+    diagnose(Tok, diag::statement_begins_with_closure);
+    diagnose(Tok, diag::discard_result_of_closure)
+      .fixItInsert(Tok.getLoc(), "_ = ");
+  }
+
   parseExprOrStmt(Result);
   if (!Result.isNull()) {
     auto Brace = BraceStmt::create(Context, StartLoc, Result, Tok.getLoc());

test/Interpreter/repl.swift

@@ -202,7 +202,7 @@ chained
 [chained]
 // CHECK: : [(f: Int -> ()) -> Int]
 
-{97210}()
+({97210}())
 // CHECK: = 97210
 true && true
 // CHECK: = true

test/decl/ext/extensions.swift

@@ -71,6 +71,8 @@ protocol P2 {}
 
 extension () {} // expected-error {{expected identifier in extension declaration}}
 // expected-error @-1{{braced block of statements is an unused closure}}
+// expected-error @-2{{cannot begin with a closure expression}}
+// expected-note @-3{{explicitly discard the result}}
 
 typealias TupleAlias = (x: Int, y: Int)
 extension TupleAlias {} // expected-error{{non-nominal type 'TupleAlias' cannot be extended}}

test/decl/func/static_func.swift

@@ -13,8 +13,8 @@ static override func gf5() {} // expected-error {{static methods may only be dec
 class override func gf6() {} // expected-error {{class methods may only be declared on a type}}{{1-6=}}
     // expected-error@-1 {{'override' can only be specified on class members}}{{7-15=}}
 
-static gf7() {} // expected-error {{expected declaration}} expected-error {{braced block of statements is an unused closure}}
-class gf8() {} // expected-error {{expected '{' in class}} expected-error {{braced block of statements is an unused closure}}
+static gf7() {} // expected-error {{expected declaration}} expected-error {{braced block of statements is an unused closure}} expected-error{{begin with a closure}} expected-note{{discard the result}}
+class gf8() {} // expected-error {{expected '{' in class}} expected-error {{braced block of statements is an unused closure}} expected-error{{begin with a closure}} expected-note{{discard the result}}
 
 func inGlobalFunc() {
   static func gf1() {} // expected-error {{static methods may only be declared on a type}}{{3-9=}}

test/decl/operators.swift

@@ -60,7 +60,7 @@ prefix func +// this should be a comment, not an operator
 prefix func -/* this also should be a comment, not an operator */
 (arg: Int) -> Int { return arg }
 
-func +*/ () {}   // expected-error {{expected identifier in function declaration}} expected-error {{unexpected end of block comment}} expected-error {{braced block of statements is an unused closure}}
+func +*/ () {}   // expected-error {{expected identifier in function declaration}} expected-error {{unexpected end of block comment}} expected-error {{braced block of statements is an unused closure}} expected-error{{begin with a closure}} expected-note{{discard the result}}
 func errors() {
   */    // expected-error {{unexpected end of block comment}}
 
@@ -161,7 +161,7 @@ func operator_in_func_bad () {
                                                                     // expected-error {{braced block of statements is an unused closure}}
 }
 
-infix operator ? {}  // expected-error {{expected operator name in operator declaration}} expected-error {{braced block of statements is an unused closure}}
+infix operator ? {}  // expected-error {{expected operator name in operator declaration}} expected-error {{braced block of statements is an unused closure}} expected-error{{begin with a closure}} expected-note{{discard the result}}
 
 infix operator ??= {}
 

test/expr/closure/closures.swift

@@ -194,3 +194,7 @@ var closureWithObservedProperty: () -> () = {
   }
 }
 
+;
+
+{}() // expected-error{{statement cannot begin with a closure}} expected-note{{explicitly discard the result of the closure}}
+

test/stmt/if_while_var.swift

@@ -30,7 +30,7 @@ if let x: B = d { }
 if let x {} // expected-error{{requires an initializer}}
 
 // TODO poor recovery in these cases
-if let {} // expected-error{{expected pattern}} expected-error{{unused closure}}
+if let {} // expected-error{{expected pattern}} expected-error{{unused closure}} expected-error{{begin with a closure}} expected-note{{discard the result}}
 if let x = {} // expected-error{{'{' after 'if'}}
 
 if let x = foo() {