Update listener error handling.

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;
 
 import 'package:dart_scanner/src/keyword.dart' show
     Keyword;
 
 import 'package:dart_scanner/src/precedence.dart' show
@@ skipping 464 matching lines @@
       listener.handleFunctionTypedFormalParameter(token);
     }
     String value = token.stringValue;
     if ((identical('=', value)) || (identical(':', value))) {
       // TODO(ahe): Validate that these are only used for optional parameters.
       Token equal = token;
       token = parseExpression(token.next);
       listener.handleValuedFormalParameter(equal, token);
       if (type.isRequired) {
         listener.reportError(
-            equal, ErrorKind.REQUIRED_PARAMETER_WITH_DEFAULT);
+            equal, ErrorKind.RequiredParameterWithDefault);
       } else if (type.isPositional && identical(':', value)) {
         listener.reportError(
-            equal, ErrorKind.POSITIONAL_PARAMETER_WITH_EQUALS);
+            equal, ErrorKind.PositionalParameterWithEquals);
       }
     }
     listener.endFormalParameter(thisKeyword);
     return token;
   }
 
   Token parseOptionalFormalParameters(Token token, bool isNamed) {
     Token begin = token;
     listener.beginOptionalFormalParameters(begin);
     assert((isNamed && optional('{', token)) || optional('[', token));
     int parameterCount = 0;
     do {
       token = token.next;
       if (isNamed && optional('}', token)) {
         break;
       } else if (!isNamed && optional(']', token)) {
         break;
       }
       var type =
           isNamed ? FormalParameterType.NAMED : FormalParameterType.POSITIONAL;
       token = parseFormalParameter(token, type);
       ++parameterCount;
     } while (optional(',', token));
     if (parameterCount == 0) {
       listener.reportError(
           token,
           isNamed
-              ? ErrorKind.EMPTY_NAMED_PARAMETER_LIST
-              : ErrorKind.EMPTY_OPTIONAL_PARAMETER_LIST);
+              ? ErrorKind.EmptyNamedParameterList
+              : ErrorKind.EmptyOptionalParameterList);
     }
     listener.endOptionalFormalParameters(parameterCount, begin, token);
     if (isNamed) {
       return expect('}', token);
     } else {
       return expect(']', token);
     }
   }
 
   Token parseTypeOpt(Token token) {
@@ skipping 466 matching lines @@
     }
     bool hasTypeOrModifier = hasType;
     if (varFinalOrConst != null) {
       parseModifier(varFinalOrConst);
       modifierCount++;
       hasTypeOrModifier = true;
       modifierList.remove(varFinalOrConst);
     }
     listener.handleModifiers(modifierCount);
     var kind = hasTypeOrModifier
-        ? ErrorKind.EXTRANEOUS_MODIFIER
-        : ErrorKind.EXTRANEOUS_MODIFIER_REPLACE;
+        ? ErrorKind.ExtraneousModifier
+        : ErrorKind.ExtraneousModifierReplace;
     for (Token modifier in modifierList) {
       listener.reportError(modifier, kind, {'modifier': modifier});
     }
     return null;
   }
 
   /// Removes the optional `covariant` token from the modifiers, if there
   /// is no `static` in the list, and `covariant` is the first modifier.
   Link<Token> removeOptCovariantTokenIfNotStatic(Link<Token> modifiers) {
     if (modifiers.isEmpty ||
@@ skipping 20 matching lines @@
         expectVarFinalOrConst(modifiers, hasType, !isTopLevel);
     bool isVar = false;
     bool hasModifier = false;
     if (varFinalOrConst != null) {
       hasModifier = true;
       isVar = optional('var', varFinalOrConst);
     }
 
     if (getOrSet != null) {
       var kind = (hasModifier || hasType)
-          ? ErrorKind.EXTRANEOUS_MODIFIER
-          : ErrorKind.EXTRANEOUS_MODIFIER_REPLACE;
+          ? ErrorKind.ExtraneousModifier
+          : ErrorKind.ExtraneousModifierReplace;
       listener.reportError(getOrSet, kind, {'modifier': getOrSet});
     }
 
     if (!hasType) {
       listener.handleNoType(name);
     } else if (optional('void', type)) {
       listener.handleNoType(name);
       // TODO(ahe): This error is reported twice, second time is from
       // [parseVariablesDeclarationMaybeSemicolon] via
       // [PartialFieldListElement.parseNode].
-      listener.reportError(type, ErrorKind.INVALID_VOID);
+      listener.reportError(type, ErrorKind.InvalidVoid);
     } else {
       parseType(type);
       if (isVar) {
-        listener.reportError(modifiers.head, ErrorKind.EXTRANEOUS_MODIFIER,
+        listener.reportError(modifiers.head, ErrorKind.ExtraneousModifier,
             {'modifier': modifiers.head});
       }
     }
 
     Token token = parseIdentifier(name);
 
     int fieldCount = 1;
     token = parseVariableInitializerOpt(token);
     while (optional(',', token)) {
       token = parseIdentifier(token.next);
@@ skipping 13 matching lines @@
   Token parseTopLevelMethod(Token start, Link<Token> modifiers, Token type,
       Token getOrSet, Token name) {
     Token externalModifier;
     // TODO(johnniwinther): Move error reporting to resolution to give more
     // specific error messages.
     for (Token modifier in modifiers) {
       if (externalModifier == null && optional('external', modifier)) {
         externalModifier = modifier;
       } else {
         listener.reportError(
-            modifier, ErrorKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
+            modifier, ErrorKind.ExtraneousModifier, {'modifier': modifier});
       }
     }
     if (externalModifier != null) {
       parseModifier(externalModifier);
       listener.handleModifiers(1);
     } else {
       listener.handleModifiers(0);
     }
 
     if (type == null) {
@@ skipping 141 matching lines @@
     } while (optional(',', token));
     mayParseFunctionExpressions = old;
     listener.endInitializers(count, begin, token);
     return token;
   }
 
   Token parseLiteralStringOrRecoverExpression(Token token) {
     if (identical(token.kind, STRING_TOKEN)) {
       return parseLiteralString(token);
     } else {
-      listener.reportError(token, ErrorKind.EXPECTED_STRING);
+      listener.reportError(token, ErrorKind.ExpectedString);
       return parseExpression(token);
     }
   }
 
   Token expectSemicolon(Token token) {
     return expect(';', token);
   }
 
   bool isModifier(Token token) {
     final String value = token.stringValue;
@@ skipping 215 matching lines @@
     Token constModifier;
     int modifierCount = 0;
     int allowedModifierCount = 1;
     // TODO(johnniwinther): Move error reporting to resolution to give more
     // specific error messages.
     for (Token modifier in modifiers) {
       if (externalModifier == null && optional('external', modifier)) {
         modifierCount++;
         externalModifier = modifier;
         if (modifierCount != allowedModifierCount) {
-          listener.reportError(modifier, ErrorKind.EXTRANEOUS_MODIFIER,
+          listener.reportError(modifier, ErrorKind.ExtraneousModifier,
               {'modifier': modifier});
         }
         allowedModifierCount++;
       } else if (staticModifier == null && optional('static', modifier)) {
         modifierCount++;
         staticModifier = modifier;
         if (modifierCount != allowedModifierCount) {
-          listener.reportError(modifier, ErrorKind.EXTRANEOUS_MODIFIER,
+          listener.reportError(modifier, ErrorKind.ExtraneousModifier,
               {'modifier': modifier});
         }
       } else if (constModifier == null && optional('const', modifier)) {
         modifierCount++;
         constModifier = modifier;
         if (modifierCount != allowedModifierCount) {
-          listener.reportError(modifier, ErrorKind.EXTRANEOUS_MODIFIER,
+          listener.reportError(modifier, ErrorKind.ExtraneousModifier,
               {'modifier': modifier});
         }
       } else {
         listener.reportError(
-            modifier, ErrorKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
+            modifier, ErrorKind.ExtraneousModifier, {'modifier': modifier});
       }
     }
     if (getOrSet != null && constModifier != null) {
-      listener.reportError(constModifier, ErrorKind.EXTRANEOUS_MODIFIER,
+      listener.reportError(constModifier, ErrorKind.ExtraneousModifier,
           {'modifier': constModifier});
     }
     parseModifierList(modifiers);
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseReturnTypeOpt(type);
     }
     Token token;
     if (optional('operator', name)) {
       token = parseOperatorName(name);
       if (staticModifier != null) {
-        listener.reportError(staticModifier, ErrorKind.EXTRANEOUS_MODIFIER,
+        listener.reportError(staticModifier, ErrorKind.ExtraneousModifier,
             {'modifier': staticModifier});
       }
     } else {
       token = parseIdentifier(name);
     }
 
     token = parseQualifiedRestOpt(token);
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
@@ skipping 167 matching lines @@
     listener.endRedirectingFactoryBody(equals, semicolon);
     return token;
   }
 
   Token skipFunctionBody(Token token, bool isExpression, bool allowAbstract) {
     assert(!isExpression);
     token = skipAsyncModifier(token);
     String value = token.stringValue;
     if (identical(value, ';')) {
       if (!allowAbstract) {
-        listener.reportError(token, ErrorKind.EXPECTED_BODY);
+        listener.reportError(token, ErrorKind.ExpectedBody);
       }
       listener.handleNoFunctionBody(token);
     } else {
       if (identical(value, '=>')) {
         token = parseExpression(token.next);
         expectSemicolon(token);
       } else if (value == '=') {
         token = parseRedirectingFactoryBody(token);
         expectSemicolon(token);
       } else {
         token = skipBlock(token);
       }
       listener.skippedFunctionBody(token);
     }
     return token;
   }
 
   Token parseFunctionBody(Token token, bool isExpression, bool allowAbstract) {
     if (optional(';', token)) {
       if (!allowAbstract) {
-        listener.reportError(token, ErrorKind.EXPECTED_BODY);
+        listener.reportError(token, ErrorKind.ExpectedBody);
       }
       listener.endFunctionBody(0, null, token);
       return token;
     } else if (optional('=>', token)) {
       Token begin = token;
       token = parseExpression(token.next);
       if (!isExpression) {
         expectSemicolon(token);
         listener.endReturnStatement(true, begin, token);
       } else {
@@ skipping 51 matching lines @@
         token = token.next;
       }
     } else if (optional('sync', token)) {
       async = token;
       token = token.next;
       if (optional('*', token)) {
         asyncAwaitKeywordsEnabled = true;
         star = token;
         token = token.next;
       } else {
-        listener.reportError(async, ErrorKind.INVALID_SYNC_MODIFIER);
+        listener.reportError(async, ErrorKind.InvalidSyncModifier);
       }
     }
     listener.handleAsyncModifier(async, star);
     return token;
   }
 
   Token parseStatement(Token token) {
     final value = token.stringValue;
     if (identical(token.kind, IDENTIFIER_TOKEN)) {
       return parseExpressionStatementOrDeclaration(token);
@@ skipping 423 matching lines @@
     return token;
   }
 
   Token parseUnaryExpression(Token token, bool allowCascades) {
     String value = token.stringValue;
     // Prefix:
     if (asyncAwaitKeywordsEnabled && optional('await', token)) {
       return parseAwaitExpression(token, allowCascades);
     } else if (identical(value, '+')) {
       // Dart no longer allows prefix-plus.
-      listener.reportError(token, ErrorKind.UNSUPPORTED_PREFIX_PLUS);
+      listener.reportError(token, ErrorKind.UnsupportedPrefixPlus);
       return parseUnaryExpression(token.next, allowCascades);
     } else if ((identical(value, '!')) ||
         (identical(value, '-')) ||
         (identical(value, '~'))) {
       Token operator = token;
       // Right associative, so we recurse at the same precedence
       // level.
       token = parsePrecedenceExpression(
           token.next, POSTFIX_PRECEDENCE, allowCascades);
       listener.handleUnaryPrefixExpression(operator);
@@ skipping 574 matching lines @@
   Token parseForStatement(Token awaitToken, Token token) {
     Token forToken = token;
     listener.beginForStatement(forToken);
     token = expect('for', token);
     token = expect('(', token);
     token = parseVariablesDeclarationOrExpressionOpt(token);
     if (optional('in', token)) {
       return parseForInRest(awaitToken, forToken, token);
     } else {
       if (awaitToken != null) {
-        listener.reportError(awaitToken, ErrorKind.INVALID_AWAIT_FOR);
+        listener.reportError(awaitToken, ErrorKind.InvalidAwaitFor);
       }
       return parseForRest(forToken, token);
     }
   }
 
   Token parseVariablesDeclarationOrExpressionOpt(Token token) {
     final String value = token.stringValue;
     if (identical(value, ';')) {
       listener.handleNoExpression(token);
       return token;
@@ skipping 307 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }