[Parse] Skip ahead if seeing any error while parsing list.

If we found any error in a list, in most cases, we cannot expect that the
following tokens could construct a valid element. Skip them, instead of trying
to parse them as the next element. This significally reduces bogus diagnostics.

Bailout if seeing tok::eof or token that can never start a element, after
parsing an element. This silences superfluous "expected ',' separator" error,
or misleading expected declaration error. What we should emit is
"expected ')' in expression list, or "expected '}' in struct".

Author: rintaro

lib/Parse/Parser.cpp

@@ -679,49 +679,40 @@ Parser::parseList(tok RightK, SourceLoc LeftLoc, SourceLoc &RightLoc,
       RightLoc = Tok.getLoc();
       return Status;
     }
-    SourceLoc SepLoc = Tok.getLoc();
-    if (consumeIf(SeparatorK)) {
-      if (Tok.is(RightK)) {
-        if (!AllowSepAfterLast) {
-          diagnose(Tok, diag::unexpected_separator,
-                   SeparatorK == tok::comma ? "," : ";")
-            .fixItRemove(SourceRange(SepLoc));
-        }
+    // If we haven't made progress, or seeing any error, skip ahead.
+    if (Tok.getLoc() == StartLoc || Status.isError()) {
+      assert(Status.isError() && "no progress without error");
+      skipUntilDeclRBrace(RightK, SeparatorK);
+      if (Tok.is(RightK) || (!OptionalSep && Tok.isNot(SeparatorK)))
         break;
+    }
+    if (consumeIf(SeparatorK)) {
+      if (Tok.isNot(RightK))
+        continue;
+      if (!AllowSepAfterLast) {
+        diagnose(Tok, diag::unexpected_separator,
+                 SeparatorK == tok::comma ? "," : ";")
+          .fixItRemove(SourceRange(PreviousLoc));
       }
-      continue;
+      break;
+    }
+    // If we're in a comma-separated list, the next token is at the
+    // beginning of a new line and can never start a element, break.
+    if (SeparatorK == tok::comma && Tok.isAtStartOfLine() &&
+        (Tok.is(tok::r_brace) || isStartOfDecl() || isStartOfStmt())) {
+      break;
+    }
+    // If we found EOF or such, bailout.
+    if (Tok.isAny(tok::eof, tok::pound_endif)) {
+      IsInputIncomplete = true;
+      break;
     }
     if (!OptionalSep) {
-      // If we're in a comma-separated list and the next token starts a new
-      // declaration at the beginning of a new line, skip until the end.
-      if (SeparatorK == tok::comma && Tok.isAtStartOfLine() &&
-          isStartOfDecl() && Tok.getLoc() != StartLoc) {
-        skipUntilDeclRBrace(RightK, SeparatorK);
-        break;
-      }
-
       StringRef Separator = (SeparatorK == tok::comma ? "," : ";");
       diagnose(Tok, diag::expected_separator, Separator)
         .fixItInsertAfter(PreviousLoc, Separator);
       Status.setIsParseError();
     }
-
-
-    // If we haven't made progress, skip ahead
-    if (Tok.getLoc() == StartLoc) {
-      skipUntilDeclRBrace(RightK, SeparatorK);
-      if (Tok.is(RightK))
-        break;
-      if (Tok.is(tok::eof) || Tok.is(tok::pound_endif)) {
-        RightLoc = PreviousLoc.isValid()? PreviousLoc : Tok.getLoc();
-        IsInputIncomplete = true;
-        Status.setIsParseError();
-        return Status;
-      }
-      if (consumeIf(SeparatorK) || OptionalSep)
-        continue;
-      break;
-    }
   }
 
   if (parseMatchingToken(RightK, RightLoc, ErrorDiag, LeftLoc)) {

test/IDE/complete_unresolved_members.swift

@@ -208,6 +208,8 @@ var Container = OptionTakerContainer1()
 Container.OptionSetTaker1(.#^UNRESOLVED_19^#
 Container.EnumTaker1(.#^UNRESOLVED_20^#
 
+func parserSync() {}
+
 // UNRESOLVED_4: Begin completions
 // UNRESOLVED_4-DAG: Decl[StaticVar]/CurrNominal:        Option1[#SomeOptions1#]; name=Option1
 // UNRESOLVED_4-DAG: Decl[StaticVar]/CurrNominal:        Option2[#SomeOptions1#]; name=Option2

test/Parse/ConditionalCompilation/decl_parse_errors.swift

@@ -27,14 +27,14 @@ lazy
 var val3: Int = 0;
 #line
 
-class C { // expected-note 3 {{in declaration of 'C'}}
+class C { // expected-note 2 {{in declaration of 'C'}} expected-note {{to match this opening '{'}}
 
 #if os(iOS)
 	func foo() {}
 } // expected-error{{expected declaration}} expected-error{{expected #else or #endif at end of conditional compilation block}}
 #else
 	func bar() {}
 	func baz() {}
-} // expected-error{{expected #else or #endif at end of conditional compilation block}} expected-error {{expected declaration}}
+} // expected-error{{expected declaration}} expected-error{{expected #else or #endif at end of conditional compilation block}}
 #endif
-// expected-error@+1{{expected declaration}}
+// expected-error@+1{{expected '}' in class}}

test/Parse/invalid.swift

@@ -15,20 +15,18 @@ func test2(inout let x : Int) {}  // expected-error {{parameter may not have mul
 func test3(f : (inout _ x : Int) -> Void) {} // expected-error {{'inout' before a parameter name is not allowed, place it before the parameter type instead}}
 
 func test3() {
-  undeclared_func( // expected-error {{use of unresolved identifier 'undeclared_func'}} expected-note {{to match this opening '('}} expected-error {{expected ',' separator}} {{19-19=,}}
+  undeclared_func( // expected-error {{use of unresolved identifier 'undeclared_func'}} expected-note {{to match this opening '('}}
 } // expected-error {{expected expression in list of expressions}} expected-error {{expected ')' in expression list}}
 
 func runAction() {} // expected-note {{did you mean 'runAction'?}}
 
 // rdar://16601779
 func foo() {
-  runAction(SKAction.sequence() // expected-error {{use of unresolved identifier 'SKAction'}}  expected-note {{to match this opening '('}} expected-error {{expected ',' separator}} {{32-32=,}}
+  runAction(SKAction.sequence() // expected-error {{use of unresolved identifier 'SKAction'}} expected-note {{to match this opening '('}} expected-error {{expected ',' separator}} {{32-32=,}}
 
-    // expected-error @+2 {{expected ',' separator}} {{12-12=,}}
-    // expected-error @+1 {{expected ',' separator}} {{12-12=,}}
     skview!
     // expected-error @-1 {{use of unresolved identifier 'skview'}}
-} // expected-error {{expected expression in list of expressions}} expected-error {{expected ')' in expression list}}
+} // expected-error {{expected ')' in expression list}}
 
 super.init() // expected-error {{'super' cannot be used outside of class members}}
 
@@ -40,15 +38,12 @@ switch state { // expected-error {{use of unresolved identifier 'state'}}
 // rdar://18926814
 func test4() {
   let abc = 123
-  _ = " >> \( abc } ) << "   // expected-note {{to match this opening '('}}  expected-error {{expected ')' in expression list}}  expected-error {{expected ',' separator}} {{18-18=,}} expected-error {{expected ',' separator}} {{18-18=,}}  expected-error {{expected expression in list of expressions}}  expected-error {{extra tokens after interpolated string expression}}
+  _ = " >> \( abc } ) << " // expected-note {{to match this opening '('}}  expected-error {{expected ')' in expression list}} expected-error {{expected ',' separator}} {{18-18=,}}  expected-error {{expected expression in list of expressions}}  expected-error {{extra tokens after interpolated string expression}}
 
 }
 
 // rdar://problem/18507467
 func d(_ b: String -> <T>() -> T) {} // expected-error {{expected type for function result}}
-// expected-error @-1 {{expected ',' separator}} {{22-22=,}}
-// expected-error @-2 {{expected parameter name followed by ':'}}
-// expected-error @-3 {{expected ',' separator}}
 
 
 // <rdar://problem/22143680> QoI: terrible diagnostic when trying to form a generic protocol

test/Parse/matching_patterns.swift

@@ -308,7 +308,7 @@ case (_?)?: break
 
 // <rdar://problem/20365753> Bogus diagnostic "refutable pattern match can fail"
 let (responseObject: Int?) = op1
-// expected-error @-1 2 {{expected ',' separator}} {{25-25=,}} {{25-25=,}}
+// expected-error @-1 {{expected ',' separator}} {{25-25=,}}
 // expected-error @-2 {{expected pattern}}
 
 

test/Parse/object_literals.swift

@@ -3,4 +3,4 @@
 let _ = [##] // expected-error{{expected identifier after '#' in object literal expression}} expected-error{{object literal syntax no longer uses '[# ... #]'}} {{9-10=}} {{11-13=}}
 let _ = [#what#] // expected-error{{object literal syntax no longer uses '[# ... #]'}} {{9-10=}} {{15-17=}}
 let _ = [#what()#] // expected-error{{object literal syntax no longer uses '[# ... #]'}} {{9-10=}} {{17-19=}}
-let _ = [#colorLiteral( // expected-error{{expected ',' separator}} expected-error{{expected expression in list of expressions}}
+let _ = [#colorLiteral( // expected-error@+1 {{expected expression in list of expressions}} expected-error @+1 {{expected ')' in expression list}} expected-note {{to match this opening '('}}

test/Parse/recovery.swift

@@ -481,19 +481,15 @@ Base=1 as Base=1  // expected-error {{cannot assign to immutable expression of t
 
 // <rdar://problem/18634543> Parser hangs at swift::Parser::parseType
 public enum TestA {
-  // expected-error @+2 {{expected ',' separator}}
   // expected-error @+1{{expected '{' in body of function declaration}}
   public static func convertFromExtenndition( // expected-error {{expected parameter name followed by ':'}}
-    // expected-error@+2 {{expected ',' separator}}
     // expected-error@+1{{expected parameter name followed by ':'}}
     s._core.count != 0, "Can't form a Character from an empty String")
 }
 
 public enum TestB {
-  // expected-error@+2 {{expected ',' separator}}
   // expected-error@+1{{expected '{' in body of function declaration}}
   public static func convertFromExtenndition( // expected-error {{expected parameter name followed by ':'}}
-    // expected-error@+2 {{expected ',' separator}}
     // expected-error@+1 {{expected parameter name followed by ':'}}
     s._core.count ?= 0, "Can't form a Character from an empty String")
 }
@@ -527,10 +523,10 @@ case let (jeb):
 // rdar://19605164
 // expected-error@+2{{use of undeclared type 'S'}}
 struct Foo19605164 {
-func a(s: S[{{g) -> Int {}  // expected-note {{to match this opening '('}}
-// expected-error@+3 {{expected parameter name followed by ':'}}
-// expected-error@+2 2 {{expected ',' separator}}
-// expected-error@+1 {{expected ')' in parameter}}
+func a(s: S[{{g) -> Int {} // expected-note {{to match this opening '('}}
+// expected-error@+3 {{expected ')' in parameter}}
+// expected-error@+2 {{expected parameter name followed by ':'}}
+// expected-error@+1 {{expected ',' separator}}
 }}}
 #endif
 
@@ -659,7 +655,7 @@ func r21712891(s : String) -> String {
   let a = s.startIndex..<s.startIndex
   _ = a
   // The specific errors produced don't actually matter, but we need to reject this.
-  return "\(s[a)"  // expected-error 3 {{}}
+  return "\(s[a)"  // expected-error {{expected ']' in expression list}} expected-note {{to match this opening '['}}
 }
 
 

test/Parse/subscripting.swift

@@ -81,9 +81,9 @@ _ = y2[0] // expected-error{{cannot use mutating getter on immutable value: 'y2'
 
 // Parsing errors
 // FIXME: Recovery here is horrible
-struct A0 { // expected-note{{in declaration of 'A0'}}
+struct A0 {
   subscript // expected-error{{expected '(' for subscript parameters}}
-    i : Int // expected-error{{expected declaration}}
+    i : Int
      -> Int {
     get {
       return stored
@@ -94,9 +94,9 @@ struct A0 { // expected-note{{in declaration of 'A0'}}
   }
 }
 
-struct A1 { // expected-note{{in declaration of 'A1'}}
+struct A1 {
   subscript (i : Int) // expected-error{{expected '->' for subscript element type}}
-     Int {  // expected-error{{expected declaration}}
+     Int {
     get {
       return stored
     }
@@ -106,9 +106,9 @@ struct A1 { // expected-note{{in declaration of 'A1'}}
   }
 }
 
-struct A2 { // expected-note{{in declaration of 'A2'}}
+struct A2 {
   subscript (i : Int) -> // expected-error{{expected subscripting element type}}
-     {  // expected-error{{expected declaration}}
+     {
     get {
       return stored
     }
@@ -118,17 +118,17 @@ struct A2 { // expected-note{{in declaration of 'A2'}}
   }
 }
 
-struct A3 { // expected-note{{in declaration of 'A3'}}
+struct A3 {
   subscript(i : Int) // expected-error {{expected '->' for subscript element type}}
-  { // expected-error {{expected declaration}}
+  {
     get {
       return i
     }
   }
 }
 
-struct A4 { // expected-note{{in declaration of 'A4'}}
-  subscript(i : Int) { // expected-error {{expected '->' for subscript element type}} expected-error {{consecutive declarations on a line must be separated by ';'}} {{21-21=;}} expected-error {{expected declaration}}
+struct A4 {
+  subscript(i : Int) { // expected-error {{expected '->' for subscript element type}}
     get {
       return i
     }
@@ -139,8 +139,8 @@ struct A5 {
   subscript(i : Int) -> Int // expected-error {{expected '{' in subscript to specify getter and setter implementation}}
 }
 
-struct A6 { // expected-note{{in declaration of 'A6'}}
-  subscript(i: Int)(j: Int) -> Int { // expected-error {{expected '->' for subscript element type}} expected-error {{consecutive declarations on a line must be separated by ';'}} {{20-20=;}} expected-error {{expected declaration}}
+struct A6 {
+  subscript(i: Int)(j: Int) -> Int { // expected-error {{expected '->' for subscript element type}}
     get {
       return i + j
     }
@@ -163,9 +163,9 @@ struct A7b {
   }
 }
 
-struct A8 { // expected-note{{in declaration of 'A8'}}
+struct A8 {
   subscript(i : Int) -> Int // expected-error{{expected '{' in subscript to specify getter and setter implementation}}
-    get { // expected-error{{expected declaration}}
+    get {
       return stored
     }
     set {

test/Sema/immutability.swift

@@ -452,11 +452,11 @@ struct StructWithDelegatingInit {
 }
 
 func test_recovery_missing_name_2(let: Int) {} // expected-error {{'let' as a parameter attribute is not allowed}}{{35-38=}} 
-// expected-error @-1 2{{expected ',' separator}} {{38-38=,}} expected-error @-1 2 {{expected parameter name followed by ':'}}
+// expected-error @-1 {{expected parameter name followed by ':'}}
 
 // <rdar://problem/16792027> compiler infinite loops on a really really mutating function
-struct F { // expected-note 2 {{in declaration of 'F'}}
-  mutating mutating mutating f() { // expected-error 2 {{duplicate modifier}} expected-note 2 {{modifier already specified here}} expected-error {{consecutive declarations on a line must be separated by ';'}} {{29-29=;}} expected-error 2 {{expected declaration}}
+struct F { // expected-note 1 {{in declaration of 'F'}}
+  mutating mutating mutating f() { // expected-error 2 {{duplicate modifier}} expected-note 2 {{modifier already specified here}} expected-error {{expected declaration}}
   }
 
   mutating nonmutating func g() {  // expected-error {{method may not be declared both mutating and nonmutating}} {{12-24=}}

test/decl/func/functions.swift

@@ -82,15 +82,15 @@ func parseError3(_ a: unknown_type, b: ) {} // expected-error {{use of undeclare
 
 func parseError4(_ a: , b: ) {} // expected-error 2{{expected parameter type following ':'}}
 
-func parseError5(_ a: b: ) {} // expected-error {{use of undeclared type 'b'}}  expected-error 2 {{expected ',' separator}} {{24-24=,}} {{24-24=,}} expected-error {{expected parameter name followed by ':'}}
+func parseError5(_ a: b: ) {} // expected-error {{use of undeclared type 'b'}}  expected-error {{expected ',' separator}} {{24-24=,}} expected-error {{expected parameter name followed by ':'}}
 
 func parseError6(_ a: unknown_type, b: ) {} // expected-error {{use of undeclared type 'unknown_type'}}  expected-error {{expected parameter type following ':'}}
 
 func parseError7(_ a: Int, goo b: unknown_type) {} // expected-error {{use of undeclared type 'unknown_type'}}
 
 public func foo(_ a: Bool = true) -> (b: Bar, c: Bar) {} // expected-error {{use of undeclared type 'Bar'}}
 
-func parenPatternInArg((a): Int) -> Int { // expected-error {{expected parameter name followed by ':'}} expected-error {{expected ',' separator}}
+func parenPatternInArg((a): Int) -> Int { // expected-error {{expected parameter name followed by ':'}}
   return a  // expected-error {{use of unresolved identifier 'a'}}
 }
 parenPatternInArg(0)  // expected-error {{argument passed to call that takes no arguments}}

test/decl/var/static_var.swift

@@ -256,11 +256,11 @@ protocol ProtosEvilTwin {
 extension ProtoAdopter : ProtosEvilTwin {}
 
 // rdar://18990358
-public struct Foo { // expected-note {{in declaration of 'Foo'}}
+public struct Foo { // expected-note {{to match this opening '{'}}}
   public static let S { a // expected-error{{computed property must have an explicit type}}
     // expected-error@-1{{type annotation missing in pattern}}
     // expected-error@-2{{'let' declarations cannot be computed properties}}
     // expected-error@-3{{use of unresolved identifier 'a'}}
 }
 
-// expected-error@+1 {{expected declaration}}
+// expected-error@+1 {{expected '}' in struct}}

test/decl/var/variables.swift

@@ -8,8 +8,8 @@ var t7, t8 : Int
 var t9, t10 = 20 // expected-error {{type annotation missing in pattern}}
 var t11, t12 : Int = 20 // expected-error {{type annotation missing in pattern}}
 var t13 = 2.0, t14 : Int
-var (x = 123, // expected-error 2 {{expected ',' separator}} {{7-7=,}} {{7-7=,}} expected-error {{expected pattern}}
-     y = 456) : (Int,Int) // expected-error 2 {{expected ',' separator}} {{7-7=,}} {{7-7=,}} expected-error {{expected pattern}}
+var (x = 123, // expected-error {{expected ',' separator}} {{7-7=,}} expected-error {{expected pattern}}
+     y = 456) : (Int,Int)
 var bfx : Int, bfy : Int
 
 _ = 10

test/expr/expressions.swift

@@ -456,10 +456,10 @@ func stringliterals(_ d: [String: Int]) {
     "something else")"
   // expected-error @-2 {{unterminated string literal}} expected-error @-1 {{unterminated string literal}}
 
-  // FIXME: bad diagnostics.
-  // expected-warning @+1 {{initialization of variable 'x2' was never used; consider replacing with assignment to '_' or removing it}}
-  /* expected-error {{unterminated string literal}} expected-error {{expected ',' separator}} expected-error {{expected ',' separator}} expected-note {{to match this opening '('}}  */ var x2 : () = ("hello" + "
-  ; // expected-error {{expected expression in list of expressions}}
+  // expected-warning @+2 {{initialization of variable 'x2' was never used; consider replacing with assignment to '_' or removing it}}
+  // expected-error @+1 {{unterminated string literal}} expected-note @+1 {{to match this opening '('}}
+  var x2 : () = ("hello" + "
+  ;
 } // expected-error {{expected ')' in expression list}}
 
 func testSingleQuoteStringLiterals() {
@@ -689,13 +689,13 @@ func dictionaryLiterals() {
 func invalidDictionaryLiteral() {
   // FIXME: lots of unnecessary diagnostics.
 
-  var a = [1: ; // expected-error {{expected value in dictionary literal}} expected-error 2{{expected ',' separator}} {{14-14=,}} {{14-14=,}} expected-error {{expected key expression in dictionary literal}} expected-error {{expected ']' in container literal expression}} expected-note {{to match this opening '['}}
-  var b = [1: ;] // expected-error {{expected value in dictionary literal}} expected-error 2{{expected ',' separator}} {{14-14=,}} {{14-14=,}} expected-error {{expected key expression in dictionary literal}}
-  var c = [1: "one" ;] // expected-error {{expected key expression in dictionary literal}} expected-error 2{{expected ',' separator}} {{20-20=,}} {{20-20=,}}
-  var d = [1: "one", ;] // expected-error {{expected key expression in dictionary literal}} expected-error {{expected ',' separator}} {{21-21=,}}
+  var a = [1: ; // expected-error {{expected value in dictionary literal}} expected-error {{expected ']' in container literal expression}} expected-note {{to match this opening '['}}
+  var b = [1: ;] // expected-error {{expected value in dictionary literal}}
+  var c = [1: "one" ;] // expected-error {{expected key expression in dictionary literal}} expected-error {{expected ',' separator}} {{20-20=,}}
+  var d = [1: "one", ;] // expected-error {{expected key expression in dictionary literal}}
   var e = [1: "one", 2] // expected-error {{expected ':' in dictionary literal}}
-  var f = [1: "one", 2 ;] // expected-error 2{{expected ',' separator}} {{23-23=,}} {{23-23=,}} expected-error 1{{expected key expression in dictionary literal}} expected-error {{expected ':' in dictionary literal}}
-  var g = [1: "one", 2: ;] // expected-error {{expected value in dictionary literal}} expected-error 2{{expected ',' separator}} {{24-24=,}} {{24-24=,}} expected-error {{expected key expression in dictionary literal}}
+  var f = [1: "one", 2 ;] // expected-error {{expected ':' in dictionary literal}}
+  var g = [1: "one", 2: ;] // expected-error {{expected value in dictionary literal}}
 }
 
 

validation-test/compiler_crashers_fixed/00058-get-self-type-for-container.swift

@@ -6,6 +6,6 @@
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
 // RUN: %target-swift-frontend %s -parse -verify
-protocol c : b { // expected-error {{use of undeclared type 'b'}} expected-note {{in declaration of 'c'}}
+protocol c : b { // expected-error {{use of undeclared type 'b'}} expected-note {{to match this opening '{'}}
 	func b // expected-error {{expected '(' in argument list of function declaration}}
-// expected-error@+1 {{expected declaration}}
+// expected-error@+1 {{expected '}' in protocol}}