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 159 matching lines @@
       if (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. It would be better to tell the
           // listener more explicitly that it must pop an identifier.

[ngeoffray, 2012/01/10 07:49:45]

Is that still a hack?

[ahe, 2012/01/10 08:02:28]

Yes. Something is wrong here, but we don't know what the user intended. Calling
endTopLevelFields keeps the node stack in the listener well balanced, but we
should explicitly tell the listener that this isn't a field.

[ngeoffray, 2012/01/10 08:07:09]

So should you do the same line 555?

[ahe, 2012/01/10 08:32:33]

Done.

-          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) {
+          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);
   }
 }