Add contextual information about identifiers to the parser listener API.

pkg/front_end/lib/src/fasta/parser/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 fasta.parser.parser;
 
 import '../scanner.dart' show
     ErrorToken;
 
 import '../scanner/recover.dart' show
@@ skipping 56 matching lines @@
 
 import 'package:front_end/src/fasta/util/link.dart' show
     Link;
 
 import 'listener.dart' show
     Listener;
 
 import 'error_kind.dart' show
     ErrorKind;
 
+import 'identifier_context.dart' show IdentifierContext;
+
 /// Returns true if [token] is the symbol or keyword [value].
 bool optional(String value, Token token) {
   return identical(value, token.stringValue);
 }
 
 class FormalParameterType {
   final String type;
   const FormalParameterType(this.type);
   bool get isRequired => this == REQUIRED;
   bool get isPositional => this == POSITIONAL;
@@ skipping 73 matching lines @@
     } else {
       return parseTopLevelMember(token);
     }
   }
 
   /// library qualified ';'
   Token parseLibraryName(Token token) {
     Token libraryKeyword = token;
     listener.beginLibraryName(libraryKeyword);
     assert(optional('library', token));
-    token = parseQualified(token.next);
+    token = parseQualified(token.next, IdentifierContext.libraryName,
+        IdentifierContext.libraryNameContinuation);
     Token semicolon = token;
     token = expect(';', token);
     listener.endLibraryName(libraryKeyword, semicolon);
     return token;
   }
 
   /// import uri (if (test) uri)* (as identifier)? combinator* ';'
   Token parseImport(Token token) {
     Token importKeyword = token;
     listener.beginImport(importKeyword);
     assert(optional('import', token));
     token = parseLiteralStringOrRecoverExpression(token.next);
     token = parseConditionalUris(token);
     Token deferredKeyword;
     if (optional('deferred', token)) {
       deferredKeyword = token;
       token = token.next;
     }
     Token asKeyword;
     if (optional('as', token)) {
       asKeyword = token;
-      token = parseIdentifier(token.next);
+      token = parseIdentifier(
+          token.next, IdentifierContext.importPrefixDeclaration);
     }
     token = parseCombinators(token);
     Token semicolon = token;
     token = expect(';', token);
     listener.endImport(importKeyword, deferredKeyword, asKeyword, semicolon);
     return token;
   }
 
   /// if (test) uri
   Token parseConditionalUris(Token token) {
@@ skipping 20 matching lines @@
     }
     token = expect(')', token);
     token = parseLiteralStringOrRecoverExpression(token);
     listener.endConditionalUri(ifKeyword, equalitySign);
     return token;
   }
 
   Token parseDottedName(Token token) {
     listener.beginDottedName(token);
     Token firstIdentifier = token;
-    token = parseIdentifier(token);
+    token = parseIdentifier(token, IdentifierContext.dottedName);
     int count = 1;
     while (optional('.', token)) {
-      token = parseIdentifier(token.next);
+      token =
+          parseIdentifier(token.next, IdentifierContext.dottedNameContinuation);
       count++;
     }
     listener.endDottedName(count, firstIdentifier);
     return token;
   }
 
   /// export uri conditional-uris* combinator* ';'
   Token parseExport(Token token) {
     Token exportKeyword = token;
     listener.beginExport(exportKeyword);
@@ skipping 41 matching lines @@
     listener.beginShow(showKeyword);
     assert(optional('show', token));
     token = parseIdentifierList(token.next);
     listener.endShow(showKeyword);
     return token;
   }
 
   /// identifier (, identifier)*
   Token parseIdentifierList(Token token) {
     listener.beginIdentifierList(token);
-    token = parseIdentifier(token);
+    token = parseIdentifier(token, IdentifierContext.combinator);
     int count = 1;
     while (optional(',', token)) {
-      token = parseIdentifier(token.next);
+      token = parseIdentifier(token.next, IdentifierContext.combinator);
       count++;
     }
     listener.endIdentifierList(count);
     return token;
   }
 
   /// type (, type)*
   Token parseTypeList(Token token) {
     listener.beginTypeList(token);
     token = parseType(token);
@@ skipping 24 matching lines @@
     token = expect(';', token);
     listener.endPart(partKeyword, semicolon);
     return token;
   }
 
   Token parsePartOf(Token token) {
     listener.beginPartOf(token);
     assert(optional('part', token));
     assert(optional('of', token.next));
     Token partKeyword = token;
-    token = parseQualified(token.next.next);
+    token = parseQualified(token.next.next, IdentifierContext.partName,
+        IdentifierContext.partNameContinuation);
     Token semicolon = token;
     token = expect(';', token);
     listener.endPartOf(partKeyword, semicolon);
     return token;
   }
 
   Token parseMetadataStar(Token token, {bool forParameter: false}) {
     listener.beginMetadataStar(token);
     int count = 0;
     while (optional('@', token)) {
       token = parseMetadata(token);
       count++;
     }
     listener.endMetadataStar(count, forParameter);
     return token;
   }
 
   /**
    * Parse
    * [: '@' qualified (‘.’ identifier)? (arguments)? :]
    */
   Token parseMetadata(Token token) {
     listener.beginMetadata(token);
     Token atToken = token;
     assert(optional('@', token));
-    token = parseIdentifier(token.next);
-    token = parseQualifiedRestOpt(token);
+    token = parseIdentifier(token.next, IdentifierContext.metadataReference);
+    token =
+        parseQualifiedRestOpt(token, IdentifierContext.metadataContinuation);
     token = parseTypeArgumentsOpt(token);
     Token period = null;
     if (optional('.', token)) {
       period = token;
-      token = parseIdentifier(token.next);
+      token = parseIdentifier(
+          token.next, IdentifierContext.metadataContinuationAfterTypeArguments);
     }
     token = parseArgumentsOpt(token);
     listener.endMetadata(atToken, period, token);
     return token;
   }
 
   Token parseTypedef(Token token) {
     Token typedefKeyword = token;
     listener.beginFunctionTypeAlias(token);
     token = parseReturnTypeOpt(token.next);
-    token = parseIdentifier(token);
+    token = parseIdentifier(token, IdentifierContext.typedefDeclaration);
     token = parseTypeVariablesOpt(token);
     token = parseFormalParameters(token);
     listener.endFunctionTypeAlias(typedefKeyword, token);
     return expect(';', token);
   }
 
   Token parseMixinApplication(Token token) {
     listener.beginMixinApplication(token);
     token = parseType(token);
     token = expect('with', token);
@@ skipping 76 matching lines @@
     }
     token = parseModifiers(token);
     // TODO(ahe): Validate that there are formal parameters if void.
     token = parseReturnTypeOpt(token);
     Token thisKeyword = null;
     if (optional('this', token)) {
       thisKeyword = token;
       // TODO(ahe): Validate field initializers are only used in
       // constructors, and not for function-typed arguments.
       token = expect('.', token.next);
+      token = parseIdentifier(token, IdentifierContext.fieldInitializer);
+    } else {
+      token =
+          parseIdentifier(token, IdentifierContext.formalParameterDeclaration);
     }
-    token = parseIdentifier(token);
     if (optional('(', token)) {
       listener.beginFunctionTypedFormalParameter(token);
       listener.handleNoTypeVariables(token);
       token = parseFormalParameters(token);
       listener.endFunctionTypedFormalParameter(token);
     } else if (optional('<', token)) {
       listener.beginFunctionTypedFormalParameter(token);
       token = parseTypeVariablesOpt(token);
       token = parseFormalParameters(token);
       listener.endFunctionTypedFormalParameter(token);
@@ skipping 138 matching lines @@
     if (identical(token.kind, GT_TOKEN)) return token.next;
     if (!identical(token.kind, GT_GT_TOKEN)) return null;
     // [token] is '>>' of which the final '>' that we are parsing is the first
     // character. In order to keep the parsing process on track we must return
     // a synthetic '>' corresponding to the second character of that '>>'.
     Token syntheticToken = new SymbolToken(GT_INFO, token.charOffset + 1);
     syntheticToken.next = token.next;
     return syntheticToken;
   }
 
-  Token parseQualified(Token token) {
-    token = parseIdentifier(token);
+  Token parseQualified(Token token, IdentifierContext context,
+      IdentifierContext continuationContext) {
+    token = parseIdentifier(token, context);
     while (optional('.', token)) {
-      token = parseQualifiedRest(token);
+      token = parseQualifiedRest(token, continuationContext);
     }
     return token;
   }
 
-  Token parseQualifiedRestOpt(Token token) {
+  Token parseQualifiedRestOpt(
+      Token token, IdentifierContext continuationContext) {
     if (optional('.', token)) {
-      return parseQualifiedRest(token);
+      return parseQualifiedRest(token, continuationContext);
     } else {
       return token;
     }
   }
 
-  Token parseQualifiedRest(Token token) {
+  Token parseQualifiedRest(Token token, IdentifierContext context) {
     assert(optional('.', token));
     Token period = token;
-    token = parseIdentifier(token.next);
+    token = parseIdentifier(token.next, context);
     listener.handleQualified(period);
     return token;
   }
 
   Token skipBlock(Token token) {
     if (!optional('{', token)) {
       return reportUnrecoverableError(token, ErrorKind.ExpectedBlockToSkip);
     }
     BeginGroupToken beginGroupToken = token;
     Token endGroup = beginGroupToken.endGroup;
     if (endGroup == null) {
       return reportUnrecoverableError(
           beginGroupToken, ErrorKind.UnmatchedToken);
     } else if (!identical(endGroup.kind, $CLOSE_CURLY_BRACKET)) {
       return reportUnrecoverableError(
           beginGroupToken, ErrorKind.UnmatchedToken);
     }
     return beginGroupToken.endGroup;
   }
 
   Token parseEnum(Token token) {
     listener.beginEnum(token);
     Token enumKeyword = token;
-    token = parseIdentifier(token.next);
+    token = parseIdentifier(token.next, IdentifierContext.enumDeclaration);
     token = expect('{', token);
     int count = 0;
     if (!optional('}', token)) {
-      token = parseIdentifier(token);
+      token = parseIdentifier(token, IdentifierContext.enumValueDeclaration);
       count++;
       while (optional(',', token)) {
         token = token.next;
         if (optional('}', token)) break;
-        token = parseIdentifier(token);
+        token = parseIdentifier(token, IdentifierContext.enumValueDeclaration);
         count++;
       }
     }
     Token endBrace = token;
     token = expect('}', token);
     listener.endEnum(enumKeyword, endBrace, count);
     return token;
   }
 
   Token parseClassOrNamedMixinApplication(Token token) {
     Token begin = token;
     Token abstractKeyword;
     if (optional('abstract', token)) {
       abstractKeyword = token;
       token = token.next;
     }
     int modifierCount = 0;
     if (abstractKeyword != null) {
       parseModifier(abstractKeyword);
       modifierCount++;
     }
     listener.handleModifiers(modifierCount);
     bool isMixinApplication = optional('=', peekAfterType(token));
     Token name = token.next;
-    token = parseIdentifier(name);
 
     if (isMixinApplication) {
+      token = parseIdentifier(name, IdentifierContext.namedMixinDeclaration);
       listener.beginNamedMixinApplication(begin, name);
     } else {
+      token = parseIdentifier(name, IdentifierContext.classDeclaration);
       listener.beginClassDeclaration(begin, name);
     }
 
     token = parseTypeVariablesOpt(token);
 
     if (optional('=', token)) {
       Token equals = token;
       token = token.next;
       return parseNamedMixinApplication(token, begin, name, equals);
     } else {
@@ skipping 42 matching lines @@
   }
 
   Token parseStringPart(Token token) {
     if (token.kind != STRING_TOKEN) {
       token = reportUnrecoverableError(token, ErrorKind.ExpectedString);
     }
     listener.handleStringPart(token);
     return token.next;
   }
 
-  Token parseIdentifier(Token token) {
+  Token parseIdentifier(Token token, IdentifierContext context) {
     if (!token.isIdentifier()) {
       token = reportUnrecoverableError(token, ErrorKind.ExpectedIdentifier);
     }
-    listener.handleIdentifier(token);
+    listener.handleIdentifier(token, context);
     return token.next;
   }
 
   Token expect(String string, Token token) {
     if (!identical(string, token.stringValue)) {
       return reportUnrecoverableError(
           token, ErrorKind.ExpectedButGot, {"expected": string});
     }
     return token.next;
   }
 
   Token parseTypeVariable(Token token) {
     listener.beginTypeVariable(token);
-    token = parseIdentifier(token);
+    token = parseIdentifier(token, IdentifierContext.typeVariableDeclaration);
     Token extendsOrSuper = null;
     if (optional('extends', token) || optional('super', token)) {
       extendsOrSuper = token;
       token = parseType(token.next);
     } else {
       listener.handleNoType(token);
     }
     listener.endTypeVariable(token, extendsOrSuper);
     return token;
   }
@@ skipping 23 matching lines @@
   }
 
   bool notEofOrValue(String value, Token token) {
     return !identical(token.kind, EOF_TOKEN) &&
         !identical(value, token.stringValue);
   }
 
   Token parseType(Token token) {
     Token begin = token;
     if (isValidTypeReference(token)) {
-      token = parseIdentifier(token);
-      token = parseQualifiedRestOpt(token);
+      token = parseIdentifier(token, IdentifierContext.typeReference);
+      token = parseQualifiedRestOpt(
+          token, IdentifierContext.typeReferenceContinuation);
     } else {
       token = reportUnrecoverableError(token, ErrorKind.ExpectedType);
       listener.handleInvalidTypeReference(token);
     }
     token = parseTypeArgumentsOpt(token);
     listener.endType(begin, token);
     return token;
   }
 
   Token parseTypeArgumentsOpt(Token token) {
@@ skipping 219 matching lines @@
       // [PartialFieldListElement.parseNode].
       reportRecoverableError(type, ErrorKind.InvalidVoid);
     } else {
       parseType(type);
       if (isVar) {
         reportRecoverableError(modifiers.head, ErrorKind.ExtraneousModifier,
             {'modifier': modifiers.head});
       }
     }
 
-    Token token = parseIdentifier(name);
+    IdentifierContext context = isTopLevel
+        ? IdentifierContext.topLevelVariableDeclaration
+        : IdentifierContext.fieldDeclaration;
+    Token token = parseIdentifier(name, context);
 
     int fieldCount = 1;
     token = parseFieldInitializerOpt(token);
     while (optional(',', token)) {
-      token = parseIdentifier(token.next);
+      token = parseIdentifier(token.next, context);
       token = parseFieldInitializerOpt(token);
       ++fieldCount;
     }
     Token semicolon = token;
     token = expectSemicolon(token);
     if (isTopLevel) {
       listener.endTopLevelFields(fieldCount, start, semicolon);
     } else {
       listener.endFields(fieldCount, start, semicolon);
     }
@@ skipping 19 matching lines @@
       listener.handleModifiers(1);
     } else {
       listener.handleModifiers(0);
     }
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseReturnTypeOpt(type);
     }
-    Token token = parseIdentifier(name);
+    Token token =
+        parseIdentifier(name, IdentifierContext.topLevelFunctionDeclaration);
 
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
     token = parseFormalParametersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     token = parseFunctionBody(token, false, externalModifier != null);
@@ skipping 418 matching lines @@
       parseReturnTypeOpt(type);
     }
     Token token;
     if (optional('operator', name)) {
       token = parseOperatorName(name);
       if (staticModifier != null) {
         reportRecoverableError(staticModifier, ErrorKind.ExtraneousModifier,
             {'modifier': staticModifier});
       }
     } else {
-      token = parseIdentifier(name);
+      token = parseIdentifier(name, IdentifierContext.methodDeclaration);
     }
 
-    token = parseQualifiedRestOpt(token);
+    token = parseQualifiedRestOpt(
+        token, IdentifierContext.methodDeclarationContinuation);
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     if (optional('=', token)) {
@@ skipping 34 matching lines @@
   }
 
   Token parseOperatorName(Token token) {
     assert(optional('operator', token));
     if (isUserDefinableOperator(token.next.stringValue)) {
       Token operator = token;
       token = token.next;
       listener.handleOperatorName(operator, token);
       return token.next;
     } else {
-      return parseIdentifier(token);
+      return parseIdentifier(token, IdentifierContext.operatorName);
     }
   }
 
   Token parseFunction(Token token, Token getOrSet) {
     listener.beginFunction(token);
     token = parseModifiers(token);
     if (identical(getOrSet, token)) {
       // get <name>  => ...
       token = token.next;
       listener.handleNoType(token);
       listener.beginFunctionName(token);
       if (optional('operator', token)) {
         token = parseOperatorName(token);
       } else {
-        token = parseIdentifier(token);
+        token =
+            parseIdentifier(token, IdentifierContext.localAccessorDeclaration);

[ahe, 2017/02/22 09:46:20]

Not 100% sure, but I think dart2js sometimes uses this for parsing top-level
functions and methods. However, as long as it doesn't use this value it
shouldn't matter.

Also, it's something that should be fixed in dart2js. It interferes with error
recovery.

       }
     } else if (optional('operator', token)) {
       // operator <op> (...
       listener.handleNoType(token);
       listener.beginFunctionName(token);
       token = parseOperatorName(token);
     } else {
       // <type>? <get>? <name>
       token = parseReturnTypeOpt(token);
       if (identical(getOrSet, token)) {
         token = token.next;
       }
       listener.beginFunctionName(token);
       if (optional('operator', token)) {
         token = parseOperatorName(token);
       } else {
-        token = parseIdentifier(token);
+        token =
+            parseIdentifier(token, IdentifierContext.localFunctionDeclaration);
       }
     }
-    token = parseQualifiedRestOpt(token);
+    token = parseQualifiedRestOpt(
+        token, IdentifierContext.localFunctionDeclarationContinuation);
     listener.endFunctionName(token);
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
@@ skipping 20 matching lines @@
     token = parseFunction(token, null);
     listener.endFunctionDeclaration(token);
     return token;
   }
 
   Token parseFunctionExpression(Token token) {
     listener.beginFunction(token);
     listener.handleModifiers(0);
     token = parseReturnTypeOpt(token);
     listener.beginFunctionName(token);
-    token = parseIdentifier(token);
+    token = parseIdentifier(token, IdentifierContext.functionExpressionName);
     listener.endFunctionName(token);
     token = parseTypeVariablesOpt(token);
     token = parseFormalParameters(token);
     listener.handleNoInitializers();
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
     asyncAwaitKeywordsEnabled = previousAsyncAwaitKeywordsEnabled;
     listener.endFunction(null, token);
     return isBlock ? token.next : token;
   }
 
   Token parseConstructorReference(Token token) {
     Token start = token;
     listener.beginConstructorReference(start);
-    token = parseIdentifier(token);
-    token = parseQualifiedRestOpt(token);
+    token = parseIdentifier(token, IdentifierContext.constructorReference);
+    token = parseQualifiedRestOpt(
+        token, IdentifierContext.constructorReferenceContinuation);
     token = parseTypeArgumentsOpt(token);
     Token period = null;
     if (optional('.', token)) {
       period = token;
-      token = parseIdentifier(token.next);
+      token = parseIdentifier(token.next,
+          IdentifierContext.constructorReferenceContinuationAfterTypeArguments);
     }
     listener.endConstructorReference(start, period, token);
     return token;
   }
 
   Token parseRedirectingFactoryBody(Token token) {
     listener.beginRedirectingFactoryBody(token);
     assert(optional('=', token));
     Token equals = token;
     token = parseConstructorReference(token.next);
@@ skipping 344 matching lines @@
         // ','.
         return parseVariablesDeclaration(token);
       }
       // Fall-through to expression statement.
     }
 
     return parseExpressionStatement(token);
   }
 
   Token parseLabel(Token token) {
-    token = parseIdentifier(token);
+    token = parseIdentifier(token, IdentifierContext.labelDeclaration);
     Token colon = token;
     token = expect(':', token);
     listener.handleLabel(colon);
     return token;
   }
 
   Token parseLabeledStatement(Token token) {
     int labelCount = 0;
     do {
       token = parseLabel(token);
@@ skipping 180 matching lines @@
   }
 
   Token parseCascadeExpression(Token token) {
     listener.beginCascade(token);
     assert(optional('..', token));
     Token cascadeOperator = token;
     token = token.next;
     if (optional('[', token)) {
       token = parseArgumentOrIndexStar(token);
     } else if (token.isIdentifier()) {
-      token = parseSend(token);
+      token = parseSend(token, IdentifierContext.expressionContinuation);
       listener.handleBinaryExpression(cascadeOperator);
     } else {
       return reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
     }
     Token mark;
     do {
       mark = token;
       if (optional('.', token)) {
         Token period = token;
-        token = parseSend(token.next);
+        token = parseSend(token.next, IdentifierContext.expressionContinuation);
         listener.handleBinaryExpression(period);
       }
       token = parseArgumentOrIndexStar(token);
     } while (!identical(mark, token));
 
     if (identical(token.info.precedence, ASSIGNMENT_PRECEDENCE)) {
       Token assignment = token;
       token = parseExpressionWithoutCascade(token.next);
       listener.handleAssignmentExpression(assignment);
     }
@@ skipping 280 matching lines @@
     // Assume the listener rejects non-string keys.
     token = parseExpression(token);
     Token colon = token;
     token = expect(':', token);
     token = parseExpression(token);
     listener.endLiteralMapEntry(colon, token);
     return token;
   }
 
   Token parseSendOrFunctionLiteral(Token token) {
-    if (!mayParseFunctionExpressions) return parseSend(token);
+    if (!mayParseFunctionExpressions) {
+      return parseSend(token, IdentifierContext.expression);
+    }
     Token peek = peekAfterIfType(token);
     if (peek != null &&
         identical(peek.kind, IDENTIFIER_TOKEN) &&
         isFunctionDeclaration(peek.next)) {
       return parseFunctionExpression(token);
     } else if (isFunctionDeclaration(token.next)) {
       return parseFunctionExpression(token);
     } else {
-      return parseSend(token);
+      return parseSend(token, IdentifierContext.expression);
     }
   }
 
   bool isFunctionDeclaration(Token token) {
     if (optional('<', token)) {
       BeginGroupToken begin = token;
       if (begin.endGroup == null) return false;
       token = begin.endGroup.next;
     }
     if (optional('(', token)) {
@@ skipping 79 matching lines @@
   Token parseLiteralSymbol(Token token) {
     Token hashToken = token;
     listener.beginLiteralSymbol(hashToken);
     token = token.next;
     if (isUserDefinableOperator(token.stringValue)) {
       listener.handleOperator(token);
       listener.endLiteralSymbol(hashToken, 1);
       return token.next;
     } else {
       int count = 1;
-      token = parseIdentifier(token);
+      token = parseIdentifier(token, IdentifierContext.literalSymbol);
       while (identical(token.stringValue, '.')) {
         count++;
-        token = parseIdentifier(token.next);
+        token = parseIdentifier(
+            token.next, IdentifierContext.literalSymbolContinuation);
       }
       listener.endLiteralSymbol(hashToken, count);
       return token;
     }
   }
 
   /**
    * Only called when [:token.kind === STRING_TOKEN:].
    */
   Token parseSingleLiteralString(Token token) {
@@ skipping 27 matching lines @@
   Token parseLiteralBool(Token token) {
     listener.handleLiteralBool(token);
     return token.next;
   }
 
   Token parseLiteralNull(Token token) {
     listener.handleLiteralNull(token);
     return token.next;
   }
 
-  Token parseSend(Token token) {
+  Token parseSend(Token token, IdentifierContext context) {
     listener.beginSend(token);
-    token = parseIdentifier(token);
+    token = parseIdentifier(token, context);
     if (isValidMethodTypeArguments(token)) {
       token = parseTypeArgumentsOpt(token);
     } else {
       listener.handleNoTypeArguments(token);
     }
     token = parseArgumentsOpt(token);
     listener.endSend(token);
     return token;
   }
 
@@ skipping 27 matching lines @@
     }
     bool old = mayParseFunctionExpressions;
     mayParseFunctionExpressions = true;
     do {
       if (optional(')', token.next)) {
         token = token.next;
         break;
       }
       Token colon = null;
       if (optional(':', token.next.next)) {
-        token = parseIdentifier(token.next);
+        token = parseIdentifier(
+            token.next, IdentifierContext.namedArgumentReference);
         colon = token;
       }
       token = parseExpression(token.next);
       if (colon != null) listener.handleNamedArgument(colon);
       ++argumentCount;
     } while (optional(',', token));
     mayParseFunctionExpressions = old;
     listener.endArguments(argumentCount, begin, token);
     return expect(')', token);
   }
@@ skipping 56 matching lines @@
       listener.endVariablesDeclaration(count, semicolon);
       return token;
     } else {
       listener.endVariablesDeclaration(count, null);
       return token;
     }
   }
 
   Token parseOptionallyInitializedIdentifier(Token token) {
     listener.beginInitializedIdentifier(token);
-    token = parseIdentifier(token);
+    token = parseIdentifier(token, IdentifierContext.localVariableDeclaration);
     token = parseVariableInitializerOpt(token);
     listener.endInitializedIdentifier();
     return token;
   }
 
   Token parseIfStatement(Token token) {
     Token ifToken = token;
     listener.beginIfStatement(ifToken);
     token = expect('if', token);
     token = parseParenthesizedExpression(token);
@@ skipping 300 matching lines @@
         statementCount, begin, token);
     return token;
   }
 
   Token parseBreakStatement(Token token) {
     assert(optional('break', token));
     Token breakKeyword = token;
     token = token.next;
     bool hasTarget = false;
     if (token.isIdentifier()) {
-      token = parseIdentifier(token);
+      token = parseIdentifier(token, IdentifierContext.labelReference);
       hasTarget = true;
     }
     listener.handleBreakStatement(hasTarget, breakKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseAssertStatement(Token token) {
     Token assertKeyword = token;
     Token commaToken = null;
     token = expect('assert', token);
@@ skipping 11 matching lines @@
     listener.handleAssertStatement(assertKeyword, commaToken, token);
     return expectSemicolon(token);
   }
 
   Token parseContinueStatement(Token token) {
     assert(optional('continue', token));
     Token continueKeyword = token;
     token = token.next;
     bool hasTarget = false;
     if (token.isIdentifier()) {
-      token = parseIdentifier(token);
+      token = parseIdentifier(token, IdentifierContext.labelReference);
       hasTarget = true;
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
@@ skipping 55 matching lines @@
         break;
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, kind, arguments);
       return null;
     } else {
       return listener.handleUnrecoverableError(token, kind, arguments);
     }
   }
 }