Restructure parser error handling and recovery.

pkg/fasta/lib/src/kernel/body_builder.dart

 // Copyright (c) 2016, 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.
 
 library fasta.body_builder;
 
 import 'package:dart_parser/src/parser.dart' show
     FormalParameterType,
     optional;
 
 import 'package:dart_parser/src/error_kind.dart' show
     ErrorKind;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show
     CloneVisitor;
 
 import 'package:kernel/transformations/flags.dart' show
     TransformerFlag;
 
 import 'package:kernel/class_hierarchy.dart' show
     ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show
     CoreTypes;
 
 import 'package:dart_scanner/src/token.dart' show
     BeginGroupToken,
-    ErrorToken,
     Token,
     isBinaryOperator,
     isMinusOperator;
 
 import '../errors.dart' show
     InputError,
     internalError;
 
 import '../errors.dart' as errors show
     inputError;
@@ skipping 2073 matching lines @@
   }
 
   @override
   void handleModifiers(int count) {
     debugEvent("Modifiers");
     // TODO(ahe): Copied from outline_builder.dart.
     push(popList(count) ?? NullValue.Modifiers);
   }
 
   @override
-  void reportErrorHelper(Token token, ErrorKind kind, Map arguments) {
-    super.reportErrorHelper(token, kind, arguments);
+  void handleRecoverableError(Token token, ErrorKind kind, Map arguments) {
+    super.handleRecoverableError(token, kind, arguments);
     if (!hasParserError) {
       print("$uri:${recoverableErrors.last}");
     }
     hasParserError = true;
   }
 
   @override
-  Token expectedExpression(Token token) {
-    if (token is ErrorToken) {
-      reportErrorToken(token);
-      push(new Throw(new StringLiteral("${recoverableErrors.last}")));
-      do {
-        token = token.next;
-      } while (token is ErrorToken);
-      return token;
-    } else {
-      push(new InvalidExpression());
-      return super.expectedExpression(token);
-    }
-  }
-
-  @override
-  Token expected(String string, Token token) {
-    if (token is ErrorToken) {
-      reportErrorToken(token);
-      do {
-        token = token.next;
-      } while (token is ErrorToken);
-      return token;
-    }
-    const List<String> trailing = const <String>[")", "}", ";", ","];
-    if (trailing.contains(token.stringValue) && trailing.contains(string)) {
-      // We're just trying to get out an error.
-      if (recoverableErrors.isNotEmpty) {
-        reportError(token, ErrorKind.Unspecified,
-            {"text": "Expected: '$string', but got '${token.value}'"});
+  Token handleUnrecoverableError(Token token, ErrorKind kind, Map arguments) {
+    if (kind == ErrorKind.UnexpectedToken) {
+      String expected = arguments["expected"];
+      const List<String> trailing = const <String>[")", "}", ";", ","];
+      if (trailing.contains(token.stringValue) && trailing.contains(expected)) {
+        arguments.putIfAbsent("actual", () => token.value);
+        handleRecoverableError(token, ErrorKind.ExpectedButGot, arguments);
       }
       return token;
     }
-    return super.expected(string, token);
+    return super.handleUnrecoverableError(token, kind, arguments);
   }
 
   void warning(error, [int charOffset = -1]) {
     String message = new InputError(uri, charOffset, error).format();
     print(message);
   }
 
   void nit(error, [int charOffset = -1]) {
     if (!showNits) return;
     String message = new InputError(uri, charOffset, error).format();
@@ skipping 468 matching lines @@
   } else if (node is TypeDeclarationBuilder) {
     return node.name;
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisPropertyAccessor) {
     return node.name.name;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }