[Parse] give more useful errors for forget 'do' keyword.

Author: JiarenWang

include/swift/Parse/Parser.h

@@ -963,6 +963,8 @@ class Parser {
   /// \returns \c true if there was a parsing error.
   bool parseTopLevelSIL();
 
+  bool isStartOfGetSetAccessor();
+
   /// Flags that control the parsing of declarations.
   enum ParseDeclFlags {
     PD_Default              = 0,

lib/Parse/ParseDecl.cpp

@@ -6683,13 +6683,19 @@ Parser::parseDeclVar(ParseDeclOptions Flags,
     // If we syntactically match the second decl-var production, with a
     // var-get-set clause, parse the var-get-set clause.
     if (Tok.is(tok::l_brace)) {
-      HasAccessors = true;
-      auto boundVar =
-          parseDeclVarGetSet(PBDEntries.back(),
-                             Flags, StaticLoc, StaticSpelling, VarLoc,
-                             PatternInit != nullptr, Attributes, Decls);
-      if (boundVar.hasCodeCompletion())
-        return makeResult(makeParserCodeCompletionStatus());
+
+      // Skip parsing the var-get-set clause if '{' is at start of line
+      // and next token is not 'didSet' or 'willSet'. Parsing as 'do'
+      // statement gives useful errors for missing 'do' before brace.
+      // See SR-14836.
+      if (!PatternInit || !Tok.isAtStartOfLine() || isStartOfGetSetAccessor()) {
+        HasAccessors = true;
+        auto boundVar = parseDeclVarGetSet(
+            PBDEntries.back(), Flags, StaticLoc, StaticSpelling, VarLoc,
+            PatternInit != nullptr, Attributes, Decls);
+        if (boundVar.hasCodeCompletion())
+          return makeResult(makeParserCodeCompletionStatus());
+      }
     }
 
     // Propagate back types for simple patterns, like "var A, B : T".

lib/Parse/ParseExpr.cpp

@@ -941,9 +941,9 @@ StringRef Parser::copyAndStripUnderscores(StringRef orig) {
 /// possibly preceded by attributes.  If so, we disambiguate the parse as the
 /// start of a get-set block in a variable definition (not as a trailing
 /// closure).
-static bool isStartOfGetSetAccessor(Parser &P) {
-  assert(P.Tok.is(tok::l_brace) && "not checking a brace?");
-  
+bool Parser::isStartOfGetSetAccessor() {
+  assert(Tok.is(tok::l_brace) && "not checking a brace?");
+
   // The only case this can happen is if the accessor label is immediately after
   // a brace (possibly preceded by attributes).  "get" is implicit, so it can't
   // be checked for.  Conveniently however, get/set properties are not allowed
@@ -952,7 +952,7 @@ static bool isStartOfGetSetAccessor(Parser &P) {
   //
   // If we have a 'didSet' or a 'willSet' label, disambiguate immediately as
   // an accessor block.
-  Token NextToken = P.peekToken();
+  Token NextToken = peekToken();
   if (NextToken.isContextualKeyword("didSet") ||
       NextToken.isContextualKeyword("willSet"))
     return true;
@@ -961,21 +961,23 @@ static bool isStartOfGetSetAccessor(Parser &P) {
   if (NextToken.isNot(tok::at_sign))
     return false;
 
-  Parser::BacktrackingScope Backtrack(P);
+  Parser::BacktrackingScope Backtrack(*this);
 
   // Eat the "{".
-  P.consumeToken(tok::l_brace);
+  consumeToken(tok::l_brace);
 
   // Eat attributes, if present.
-  while (P.consumeIf(tok::at_sign)) {
-    if (!P.consumeIf(tok::identifier)) return false;
+  while (consumeIf(tok::at_sign)) {
+    if (!consumeIf(tok::identifier))
+      return false;
     // Eat paren after attribute name; e.g. @foo(x)
-    if (P.Tok.is(tok::l_paren)) P.skipSingle();
+    if (Tok.is(tok::l_paren))
+      skipSingle();
   }
 
   // Check if we have 'didSet'/'willSet' after attributes.
-  return P.Tok.isContextualKeyword("didSet") ||
-         P.Tok.isContextualKeyword("willSet");
+  return Tok.isContextualKeyword("didSet") ||
+         Tok.isContextualKeyword("willSet");
 }
 
 /// Recover invalid uses of trailing closures in a situation
@@ -987,7 +989,7 @@ static bool isValidTrailingClosure(bool isExprBasic, Parser &P){
 
   // If this is the start of a get/set accessor, then it isn't a trailing
   // closure.
-  if (isStartOfGetSetAccessor(P))
+  if (P.isStartOfGetSetAccessor())
     return false;
 
   // If this is a normal expression (not an expr-basic) then trailing closures

test/Constraints/closures.swift

@@ -89,9 +89,9 @@ func test13811882() {
 // <rdar://problem/21544303> QoI: "Unexpected trailing closure" should have a fixit to insert a 'do' statement
 // <https://bugs.swift.org/browse/SR-3671>
 func r21544303() {
-  var inSubcall = true
-  {
-  }  // expected-error {{computed property must have accessors specified}}
+  var inSubcall = true 
+  {  // expected-error {{closure expression is unused}} expected-note {{did you mean to use a 'do' statement?}}
+  }  
   inSubcall = false
 
   // This is a problem, but isn't clear what was intended.

test/expr/closure/let.swift

@@ -11,3 +11,9 @@ func foo() {
   _ = { x = 0 }() // expected-error{{'x' is a 'let'}}
   _ = { frob(x: x); x = 0 }() // expected-error 2 {{'x' is a 'let'}}
 }
+
+let a: Int 
+{ 1 } // expected-error{{'let' declarations cannot be computed properties}}
+
+let b: Int = 1
+{ didSet { print("didSet") } } // expected-error{{'let' declarations cannot be observing properties}}