Update dart2js unit tests to dart_parser and dart_scanner.

pkg/dart_parser/lib/src/parser.dart

 // Copyright (c) 2012, 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 dart_parser.parser;
 
 import 'package:dart_scanner/src/keyword.dart' show
     Keyword;
 
 import 'package:dart_scanner/src/precedence.dart' show
@@ skipping 834 matching lines @@
         !identical(value, token.stringValue);
   }
 
   Token parseType(Token token) {
     Token begin = token;
     if (isValidTypeReference(token)) {
       token = parseIdentifier(token);
       token = parseQualifiedRestOpt(token);
     } else {
       token = reportUnrecoverableError(token, ErrorKind.ExpectedType);
+      listener.handleInvalidTypeReference(token);
     }
     token = parseTypeArgumentsOpt(token);
     listener.endType(begin, token);
     return token;
   }
 
   Token parseTypeArgumentsOpt(Token token) {
     return parseStuff(
         token,
         (t) => listener.beginTypeArguments(t),
@@ skipping 920 matching lines @@
         expectSemicolon(token);
         listener.endReturnStatement(true, begin, token);
       } else {
         listener.endReturnStatement(true, begin, null);
       }
       return token;
     }
     Token begin = token;
     int statementCount = 0;
     if (!optional('{', token)) {
-      return reportUnrecoverableError(token, ErrorKind.ExpectedFunctionBody);
+      token = reportUnrecoverableError(token, ErrorKind.ExpectedFunctionBody);
+      listener.handleInvalidFunctionBody(token);
+      return token;
     }
 
     listener.beginFunctionBody(begin);
     token = token.next;
     while (notEofOrValue('}', token)) {
       token = parseStatement(token);
       ++statementCount;
     }
     listener.endFunctionBody(statementCount, begin, token);
     expect('}', token);
@@ skipping 553 matching lines @@
       } else if (value == 'super') {
         return parseSuperExpression(token);
       } else if (value == 'new') {
         return parseNewExpression(token);
       } else if (value == 'const') {
         return parseConstExpression(token);
       } else if (value == 'void') {
         return parseFunctionExpression(token);
       } else if (asyncAwaitKeywordsEnabled &&
           (value == 'yield' || value == 'async')) {
-        return reportUnrecoverableError(token, ErrorKind.ExpectedExpression);
+        return expressionExpected(token);
       } else if (token.isIdentifier()) {
         return parseSendOrFunctionLiteral(token);
       } else {
-        return reportUnrecoverableError(token, ErrorKind.ExpectedExpression);
+        return expressionExpected(token);
       }
     } else if (kind == OPEN_PAREN_TOKEN) {
       return parseParenthesizedExpressionOrFunctionLiteral(token);
     } else if (kind == OPEN_SQUARE_BRACKET_TOKEN || token.stringValue == '[]') {
       listener.handleNoTypeArguments(token);
       return parseLiteralListSuffix(token, null);
     } else if (kind == OPEN_CURLY_BRACKET_TOKEN) {
       listener.handleNoTypeArguments(token);
       return parseLiteralMapSuffix(token, null);
     } else if (kind == LT_TOKEN) {
       return parseLiteralListOrMapOrFunction(token, null);
     } else {
-      return reportUnrecoverableError(token, ErrorKind.ExpectedExpression);
+      return expressionExpected(token);
     }
   }
 
+  Token expressionExpected(Token token) {
+    token = reportUnrecoverableError(token, ErrorKind.ExpectedExpression);
+    listener.handleInvalidExpression(token);
+    return token;
+  }
+
   Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
     BeginGroupToken beginGroup = token;
     // TODO(eernst): Check for NPE as described in issue 26252.
     Token nextToken = beginGroup.endGroup.next;
     int kind = nextToken.kind;
     if (mayParseFunctionExpressions &&
         (identical(kind, FUNCTION_TOKEN) ||
             identical(kind, OPEN_CURLY_BRACKET_TOKEN) ||
             (identical(kind, KEYWORD_TOKEN) &&
                 (nextToken.value == 'async' || nextToken.value == 'sync')))) {
@@ skipping 905 matching lines @@
     r'${': '}',
   }[openBrace];
 }
 
 Token skipToEof(Token token) {
   while (!identical(token.info, EOF_INFO)) {
     token = token.next;
   }
   return token;
 }