Better error recovery.

dart/frog/leg/scanner/parser.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list.
  */
 class Parser {
   final Listener listener;
@@ skipping 170 matching lines @@
     if (value === 'default') return true;
     if (value === 'factory') {
       listener.recoverableError("expected 'default'", token: token);
       return true;
     }
     return false;
   }
 
   Token skipBlock(Token token) {
     if (!optional('{', token)) {
-      return listener.expectedBlock(token);
+      return listener.unexpected(token);
     }
     BeginGroupToken beginGroupToken = token;
     assert(beginGroupToken.endGroup === null ||
            beginGroupToken.endGroup.kind === $CLOSE_CURLY_BRACKET);
     return beginGroupToken.endGroup;
   }
 
   Token parseClass(Token token) {
     Token begin = token;
     listener.beginClassDeclaration(token);
@@ skipping 160 matching lines @@
         isField = false;
         break;
       } else if ((value === '=') || (value === ';') || (value === ',')) {
         isField = true;
         break;
       } else {
         token = listener.unexpected(token);
         if (token.kind === EOF_TOKEN) {
           // TODO(ahe): This is a hack. It would be better to tell the
           // listener more explicitly that it must pop an identifier.
-          listener.endTopLevelFields(0, start, token);
+          listener.endTopLevelFields(1, start, token);
           return token;
         }
       }
     }
     if (isField) {
       int fieldCount = 1;
       token = parseVariableInitializerOpt(token);
       while (optional(',', token)) {
         token = parseIdentifier(token.next);
         token = parseVariableInitializerOpt(token);
@@ skipping 89 matching lines @@
       token = parseModifier(token);
       count++;
     }
     listener.handleModifiers(count);
     return token;
   }
 
   Token peekAfterType(Token token) {
     // TODO(ahe): Also handle var?
     if ('void' !== token.stringValue && !isIdentifier(token)) {
-      listener.expectedIdentifier(token);
+      listener.unexpected(token);
     }
     // We are looking at "identifier ...".
     Token peek = token.next;
     if (peek.kind === PERIOD_TOKEN) {
       if (isIdentifier(peek.next)) {
         // Look past a library prefix.
         peek = peek.next.next;
       }
     }
     // We are looking at "qualified ...".
     if (peek.kind === LT_TOKEN) {
       // Possibly generic type.
       // We are looking at "qualified '<'".
       BeginGroupToken beginGroupToken = peek;
       Token gtToken = beginGroupToken.endGroup;
       if (gtToken !== null) {
         // We are looking at "qualified '<' ... '>' ...".
         return gtToken.next;
       }
     }
     return peek;
   }
 
   Token parseClassBody(Token token) {
     Token begin = token;
     listener.beginClassBody(token);
     if (!optional('{', token)) {
-      return listener.expectedBlock(token);
+      token = listener.unexpected(token);
+      listener.endClassBody(0, begin, null);
+      return token;
     }
     token = token.next;
     int count = 0;
     while (notEofOrValue('}', token)) {
       token = parseMember(token);
       ++count;
     }
     listener.endClassBody(count, begin, token);
     return token;
   }
@@ skipping 21 matching lines @@
       // error handling.
       final String value = token.stringValue;
       if ((value === '(') || (value === '.')) {
         isField = false;
         break;
       } else if ((value === '=') || (value === ';') || (value === ',')) {
         isField = true;
         break;
       } else {
         token = listener.unexpected(token);
+        if (token.kind === EOF_TOKEN) {
+          // TODO(ahe): This is a hack, see parseTopLevelMember.
+          listener.endFields(1, start, token);
+          return token;
+        }
       }
     }
     if (isField) {
       int fieldCount = 1;
       token = parseVariableInitializerOpt(token);
       while (optional(',', token)) {
         // TODO(ahe): Count these.
         token = parseIdentifier(token.next);
         token = parseVariableInitializerOpt(token);
         ++fieldCount;
@@ skipping 426 matching lines @@
       token = parseParenthesizedExpression(token);
       mayParseFunctionExpressions = old;
       return token;
     }
   }
 
   Token parseParenthesizedExpression(Token token) {
     BeginGroupToken begin = token;
     token = expect('(', token);
     token = parseExpression(token);
-    assert(begin.endGroup === token);
+    if (begin.endGroup !== token) {
+      listener.unexpected(token);
+      token = begin.endGroup;
+    }
     listener.handleParenthesizedExpression(begin);
     return expect(')', token);
   }
 
   Token parseThisExpression(Token token) {
     listener.handleThisExpression(token);
     token = token.next;
     if (optional('(', token)) {
       // Constructor forwarding.
       token = parseArguments(token);
@@ skipping 94 matching lines @@
 
   Token parseNewExpression(Token token) {
     Token newKeyword = token;
     token = expect('new', token);
     token = parseType(token);
     bool named = false;
     if (optional('.', token)) {
       named = true;
       token = parseIdentifier(token.next);
     }
-    token = parseArguments(token);
+    if (optional('(', token)) {
+      token = parseArguments(token);
+    } else {
+      listener.handleNoArguments(token);
+      token = listener.unexpected(token);
+    }
     listener.handleNewExpression(newKeyword, named);
     return token;
   }
 
   Token parseConstExpression(Token token) {
     Token constKeyword = token;
     token = expect('const', token);
     final String value = token.stringValue;
     if ((value === '<') ||
         (value === '[') ||
@@ skipping 329 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }