Distinguish SimpleIdentifier uses and declarations at parse time.

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, 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 analyzer.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 660 matching lines @@
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitCatchClause(CatchClause node) {
     if (identical(_oldNode, node.exceptionType)) {
       return _parser.parseTypeName();
     } else if (identical(_oldNode, node.exceptionParameter)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     } else if (identical(_oldNode, node.stackTraceParameter)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     } else if (identical(_oldNode, node.body)) {
       return _parser.parseBlock();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitClassDeclaration(ClassDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
@@ skipping 21 matching lines @@
     return _notAChild(node);
   }
 
   @override
   AstNode visitClassTypeAlias(ClassTypeAlias node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.name)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     } else if (identical(_oldNode, node.typeParameters)) {
       return _parser.parseTypeParameterList();
     } else if (identical(_oldNode, node.superclass)) {
       return _parser.parseTypeName();
     } else if (identical(_oldNode, node.withClause)) {
       return _parser.parseWithClause();
     } else if (identical(_oldNode, node.implementsClause)) {
       return _parser.parseImplementsClause();
     }
     return _notAChild(node);
@@ skipping 142 matching lines @@
   @override
   AstNode visitEmptyStatement(EmptyStatement node) => _notAChild(node);
 
   @override
   AstNode visitEnumConstantDeclaration(EnumConstantDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.name)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitEnumDeclaration(EnumDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.name)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     } else if (node.constants.contains(_oldNode)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitExportDirective(ExportDirective node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
@@ skipping 59 matching lines @@
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitForEachStatement(ForEachStatement node) {
     if (identical(_oldNode, node.loopVariable)) {
       throw new InsufficientContextException();
       //return parser.parseDeclaredIdentifier();
     } else if (identical(_oldNode, node.identifier)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     } else if (identical(_oldNode, node.body)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitFormalParameterList(FormalParameterList node) {
     // We don't know which kind of parameter to parse.
     throw new InsufficientContextException();
@@ skipping 17 matching lines @@
 
   @override
   AstNode visitFunctionDeclaration(FunctionDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       return _parser.parseReturnType();
     } else if (identical(_oldNode, node.name)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     } else if (identical(_oldNode, node.functionExpression)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     if (identical(_oldNode, node.functionDeclaration)) {
       throw new InsufficientContextException();
@@ skipping 23 matching lines @@
 
   @override
   AstNode visitFunctionTypeAlias(FunctionTypeAlias node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       return _parser.parseReturnType();
     } else if (identical(_oldNode, node.name)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     } else if (identical(_oldNode, node.typeParameters)) {
       return _parser.parseTypeParameterList();
     } else if (identical(_oldNode, node.parameters)) {
       return _parser.parseFormalParameterList();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       return _parser.parseReturnType();
     } else if (identical(_oldNode, node.identifier)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     } else if (identical(_oldNode, node.parameters)) {
       return _parser.parseFormalParameterList();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitHideCombinator(HideCombinator node) {
     if (node.hiddenNames.contains(_oldNode)) {
       return _parser.parseSimpleIdentifier();
@@ skipping 23 matching lines @@
 
   @override
   AstNode visitImportDirective(ImportDirective node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.uri)) {
       return _parser.parseStringLiteral();
     } else if (identical(_oldNode, node.prefix)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     } else if (node.combinators.contains(_oldNode)) {
       return _parser.parseCombinator();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitIndexExpression(IndexExpression node) {
     if (identical(_oldNode, node.target)) {
       throw new InsufficientContextException();
@@ skipping 39 matching lines @@
       return _parser.parseBitwiseOrExpression();
     } else if (identical(_oldNode, node.type)) {
       return _parser.parseTypeName();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitLabel(Label node) {
     if (identical(_oldNode, node.label)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(
+          isDeclaration: node.parent is LabeledStatement);
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitLabeledStatement(LabeledStatement node) {
     if (node.labels.contains(_oldNode)) {
-      return _parser.parseLabel();
+      return _parser.parseLabel(isDeclaration: true);
     } else if (identical(_oldNode, node.statement)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitLibraryDirective(LibraryDirective node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
@@ skipping 50 matching lines @@
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       throw new InsufficientContextException();
       //return parser.parseTypeName();
       //return parser.parseReturnType();
     } else if (identical(_oldNode, node.name)) {
       if (node.operatorKeyword != null) {
         throw new InsufficientContextException();
       }
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     } else if (identical(_oldNode, node.body)) {
       //return parser.parseFunctionBody();
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.parameters)) {
       // TODO(paulberry): if we want errors to be correct, we'll need to also
       // call _validateFormalParameterList, and sometimes
       // _validateModifiersForGetterOrSetterOrMethod.
       return _parser.parseFormalParameterList();
     }
     return _notAChild(node);
@@ skipping 274 matching lines @@
     return _notAChild(node);
   }
 
   @override
   AstNode visitTypeParameter(TypeParameter node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.name)) {
-      return _parser.parseSimpleIdentifier();
+      return _parser.parseSimpleIdentifier(isDeclaration: true);
     } else if (identical(_oldNode, node.bound)) {
       return _parser.parseTypeName();
     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitTypeParameterList(TypeParameterList node) {
     if (node.typeParameters.contains(node)) {
       return _parser.parseTypeParameter();
@@ skipping 963 matching lines @@
         // name, parameters and empty body.
         //
         return new MethodDeclaration(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
             null,
             null,
             null,
             null,
             null,
-            _createSyntheticIdentifier(),
+            _createSyntheticIdentifier(isDeclaration: true),
             null,
             new FormalParameterList(
-                null, new List<FormalParameter>(), null, null, null),
+                null, <FormalParameter>[], null, null, null),
             new EmptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON)));
       }
       return null;
     } else if (_tokenMatches(_peek(), TokenType.PERIOD) &&
         _tokenMatchesIdentifier(_peekAt(2)) &&
         _tokenMatches(_peekAt(3), TokenType.OPEN_PAREN)) {
       return _parseConstructor(
           commentAndMetadata,
           modifiers.externalKeyword,
           _validateModifiersForConstructor(modifiers),
           modifiers.factoryKeyword,
           parseSimpleIdentifier(),
           getAndAdvance(),
-          parseSimpleIdentifier(),
+          parseSimpleIdentifier(isDeclaration: true),
           parseFormalParameterList());
     } else if (_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
       TypeName returnType = _parseOptionalTypeNameComment();
-      SimpleIdentifier methodName = parseSimpleIdentifier();
+      SimpleIdentifier methodName = parseSimpleIdentifier(isDeclaration: true);
       TypeParameterList typeParameters = _parseGenericCommentTypeParameters();
       FormalParameterList parameters = parseFormalParameterList();
       if (_matches(TokenType.COLON) ||
           modifiers.factoryKeyword != null ||
           methodName.name == className) {
         return _parseConstructor(
             commentAndMetadata,
             modifiers.externalKeyword,
             _validateModifiersForConstructor(modifiers),
             modifiers.factoryKeyword,
-            methodName,
+            new SimpleIdentifier(methodName.token, isDeclaration: false),
             null,
             null,
             parameters);
       }
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       _validateFormalParameterList(parameters);
       return _parseMethodDeclarationAfterParameters(
           commentAndMetadata,
           modifiers.externalKeyword,
           modifiers.staticKeyword,
@@ skipping 71 matching lines @@
         _lockErrorListener();
         return _parseInitializedIdentifierList(
             commentAndMetadata,
             modifiers.staticKeyword,
             _validateModifiersForField(modifiers),
             type);
       } finally {
         _unlockErrorListener();
       }
     } else if (_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
-      SimpleIdentifier methodName = parseSimpleIdentifier();
+      SimpleIdentifier methodName = parseSimpleIdentifier(isDeclaration: true);
       TypeParameterList typeParameters = _parseGenericCommentTypeParameters();
       FormalParameterList parameters = parseFormalParameterList();
       if (methodName.name == className) {
         _reportErrorForNode(ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE, type);
         return _parseConstructor(
             commentAndMetadata,
             modifiers.externalKeyword,
             _validateModifiersForConstructor(modifiers),
             modifiers.factoryKeyword,
-            methodName,
+            new SimpleIdentifier(methodName.token, isDeclaration: true),
             null,
             null,
             parameters);
       }
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       _validateFormalParameterList(parameters);
       return _parseMethodDeclarationAfterParameters(
           commentAndMetadata,
           modifiers.externalKeyword,
           modifiers.staticKeyword,
@@ skipping 535 matching lines @@
     }
     return new ImplementsClause(keyword, interfaces);
   }
 
   /**
    * Parse a label. Return the label that was parsed.
    *
    *     label ::=
    *         identifier ':'
    */
-  Label parseLabel() {
-    SimpleIdentifier label = parseSimpleIdentifier();
+  Label parseLabel({bool isDeclaration: false}) {
+    SimpleIdentifier label =
+        parseSimpleIdentifier(isDeclaration: isDeclaration);
     Token colon = _expect(TokenType.COLON);
     return new Label(label, colon);
   }
 
   /**
    * Parse a library identifier. Return the library identifier that was parsed.
    *
    *     libraryIdentifier ::=
    *         identifier ('.' identifier)*
    */
@@ skipping 71 matching lines @@
       FormalParameterList parameters = parseFormalParameterList();
       if (thisKeyword == null) {
         if (holder.keyword != null) {
           _reportErrorForToken(
               ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, holder.keyword);
         }
         return new FunctionTypedFormalParameter(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
             holder.type,
-            identifier,
+            new SimpleIdentifier(identifier.token, isDeclaration: true),
             typeParameters,
             parameters);
       } else {
         return new FieldFormalParameter(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
             holder.keyword,
             holder.type,
             thisKeyword,
             period,
@@ skipping 24 matching lines @@
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           holder.keyword,
           holder.type,
           thisKeyword,
           period,
           identifier,
           null,
           null);
     }
-    return new SimpleFormalParameter(commentAndMetadata.comment,
-        commentAndMetadata.metadata, holder.keyword, holder.type, identifier);
+    return new SimpleFormalParameter(
+        commentAndMetadata.comment,
+        commentAndMetadata.metadata,
+        holder.keyword,
+        holder.type,
+        new SimpleIdentifier(identifier.token, isDeclaration: true));
   }
 
   /**
    * Parse a prefixed identifier. Return the prefixed identifier that was
    * parsed.
    *
    *     prefixedIdentifier ::=
    *         identifier ('.' identifier)?
    */
   Identifier parsePrefixedIdentifier() {
@@ skipping 20 matching lines @@
       return parseTypeName();
     }
   }
 
   /**
    * Parse a simple identifier. Return the simple identifier that was parsed.
    *
    *     identifier ::=
    *         IDENTIFIER
    */
-  SimpleIdentifier parseSimpleIdentifier() {
+  SimpleIdentifier parseSimpleIdentifier({bool isDeclaration: false}) {
     if (_matchesIdentifier()) {
       String lexeme = _currentToken.lexeme;
       if ((_inAsync || _inGenerator) &&
           (lexeme == 'async' || lexeme == 'await' || lexeme == 'yield')) {
         _reportErrorForCurrentToken(
             ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER);
       }
-      return new SimpleIdentifier(getAndAdvance());
+      return new SimpleIdentifier(getAndAdvance(),
+          isDeclaration: isDeclaration);
     }
     _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
-    return _createSyntheticIdentifier();
+    return _createSyntheticIdentifier(isDeclaration: isDeclaration);
   }
 
   /**
    * Parse a statement, starting with the given [token]. Return the statement
    * that was parsed, or `null` if the tokens do not represent a recognizable
    * statement.
    */
   Statement parseStatement(Token token) {
     _currentToken = token;
     return parseStatement2();
@@ skipping 94 matching lines @@
   }
 
   /**
    * Parse a type parameter. Return the type parameter that was parsed.
    *
    *     typeParameter ::=
    *         metadata name ('extends' bound)?
    */
   TypeParameter parseTypeParameter() {
     CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
-    SimpleIdentifier name = parseSimpleIdentifier();
+    SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     if (_matchesKeyword(Keyword.EXTENDS)) {
       Token keyword = getAndAdvance();
       TypeName bound = parseTypeName();
       return new TypeParameter(commentAndMetadata.comment,
           commentAndMetadata.metadata, name, keyword, bound);
     }
     return new TypeParameter(commentAndMetadata.comment,
         commentAndMetadata.metadata, name, null, null);
   }
 
@@ skipping 149 matching lines @@
           _matchesIdentifier()) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Return a synthetic identifier.
    */
-  SimpleIdentifier _createSyntheticIdentifier() {
+  SimpleIdentifier _createSyntheticIdentifier({bool isDeclaration: false}) {
     Token syntheticToken;
     if (_currentToken.type == TokenType.KEYWORD) {
       // Consider current keyword token as an identifier.
       // It is not always true, e.g. "^is T" where "^" is place the place for
       // synthetic identifier. By creating SyntheticStringToken we can
       // distinguish a real identifier from synthetic. In the code completion
       // behavior will depend on a cursor position - before or on "is".
       syntheticToken = _injectToken(new SyntheticStringToken(
           TokenType.IDENTIFIER, _currentToken.lexeme, _currentToken.offset));
     } else {
       syntheticToken = _createSyntheticToken(TokenType.IDENTIFIER);
     }
-    return new SimpleIdentifier(syntheticToken);
+    return new SimpleIdentifier(syntheticToken, isDeclaration: isDeclaration);
   }
 
   /**
    * Return a synthetic token representing the given [keyword].
    */
   Token _createSyntheticKeyword(Keyword keyword) => _injectToken(
       new Parser_SyntheticKeywordToken(keyword, _currentToken.offset));
 
   /**
    * Return a synthetic string literal.
@@ skipping 1007 matching lines @@
         next = _skipTypeParameterList(next);
         if (next != null && _tokenMatches(next, TokenType.EQ)) {
           return _parseClassTypeAlias(
               commentAndMetadata, abstractKeyword, keyword);
         }
       } else if (_tokenMatches(next, TokenType.EQ)) {
         return _parseClassTypeAlias(
             commentAndMetadata, abstractKeyword, keyword);
       }
     }
-    SimpleIdentifier name = parseSimpleIdentifier();
+    SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     String className = name.name;
     TypeParameterList typeParameters = null;
     if (_matches(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
     }
     //
     // Parse the clauses. The parser accepts clauses in any order, but will
     // generate errors if they are not in the order required by the
     // specification.
     //
@@ skipping 132 matching lines @@
    * 'class' keyword. Return the class type alias that was parsed.
    *
    *     classTypeAlias ::=
    *         identifier typeParameters? '=' 'abstract'? mixinApplication
    *
    *     mixinApplication ::=
    *         type withClause implementsClause? ';'
    */
   ClassTypeAlias _parseClassTypeAlias(CommentAndMetadata commentAndMetadata,
       Token abstractKeyword, Token classKeyword) {
-    SimpleIdentifier className = parseSimpleIdentifier();
+    SimpleIdentifier className = parseSimpleIdentifier(isDeclaration: true);
     TypeParameterList typeParameters = null;
     if (_matches(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
     }
     Token equals = _expect(TokenType.EQ);
     TypeName superclass = parseTypeName();
     WithClause withClause = null;
     if (_matchesKeyword(Keyword.WITH)) {
       withClause = parseWithClause();
     } else {
@@ skipping 788 matching lines @@
    *
    *     emptyStatement ::=
    *         ';'
    */
   Statement _parseEmptyStatement() => new EmptyStatement(getAndAdvance());
 
   EnumConstantDeclaration _parseEnumConstantDeclaration() {
     CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
     SimpleIdentifier name;
     if (_matchesIdentifier()) {
-      name = parseSimpleIdentifier();
+      name = parseSimpleIdentifier(isDeclaration: true);
     } else {
       name = _createSyntheticIdentifier();
     }
     if (commentAndMetadata.metadata.isNotEmpty) {
       _reportErrorForNode(ParserErrorCode.ANNOTATION_ON_ENUM_CONSTANT,
           commentAndMetadata.metadata[0]);
     }
     return new EnumConstantDeclaration(
         commentAndMetadata.comment, commentAndMetadata.metadata, name);
   }
 
   /**
    * Parse an enum declaration. The [commentAndMetadata] is the metadata to be
    * associated with the member. Return the enum declaration that was parsed.
    *
    *     enumType ::=
    *         metadata 'enum' id '{' id (',' id)* (',')? '}'
    */
   EnumDeclaration _parseEnumDeclaration(CommentAndMetadata commentAndMetadata) {
     Token keyword = _expectKeyword(Keyword.ENUM);
-    SimpleIdentifier name = parseSimpleIdentifier();
+    SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     Token leftBracket = null;
     List<EnumConstantDeclaration> constants =
         new List<EnumConstantDeclaration>();
     Token rightBracket = null;
     if (_matches(TokenType.OPEN_CURLY_BRACKET)) {
       leftBracket = _expect(TokenType.OPEN_CURLY_BRACKET);
       if (_matchesIdentifier() || _matches(TokenType.AT)) {
         constants.add(_parseEnumConstantDeclaration());
       } else if (_matches(TokenType.COMMA) &&
           _tokenMatchesIdentifier(_peek())) {
@@ skipping 242 matching lines @@
                   [variables.length.toString()]);
             }
             VariableDeclaration variable = variables[0];
             if (variable.initializer != null) {
               _reportErrorForCurrentToken(
                   ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH);
             }
             Token keyword = variableList.keyword;
             TypeName type = variableList.type;
             if (keyword != null || type != null) {
-              loopVariable = new DeclaredIdentifier(commentAndMetadata.comment,
-                  commentAndMetadata.metadata, keyword, type, variable.name);
+              loopVariable = new DeclaredIdentifier(
+                  commentAndMetadata.comment,
+                  commentAndMetadata.metadata,
+                  keyword,
+                  type,
+                  new SimpleIdentifier(variable.name.token,
+                      isDeclaration: true));
             } else {
               if (!commentAndMetadata.metadata.isEmpty) {
                 // TODO(jwren) metadata isn't allowed before the identifier in
                 // "identifier in expression", add warning if commentAndMetadata
                 // has content
               }
               identifier = variable.name;
             }
           }
           Token inKeyword = getAndAdvance();
@@ skipping 190 matching lines @@
     Token keyword = null;
     bool isGetter = false;
     if (_matchesKeyword(Keyword.GET) &&
         !_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
       keyword = getAndAdvance();
       isGetter = true;
     } else if (_matchesKeyword(Keyword.SET) &&
         !_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
       keyword = getAndAdvance();
     }
-    SimpleIdentifier name = parseSimpleIdentifier();
+    SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
     FormalParameterList parameters = null;
     if (!isGetter) {
       if (_matches(TokenType.OPEN_PAREN)) {
         parameters = parseFormalParameterList();
         _validateFormalParameterList(parameters);
       } else {
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
         parameters = new FormalParameterList(
@@ skipping 79 matching lines @@
    *
    *     functionPrefix ::=
    *         returnType? name
    */
   FunctionTypeAlias _parseFunctionTypeAlias(
       CommentAndMetadata commentAndMetadata, Token keyword) {
     TypeName returnType = null;
     if (hasReturnTypeInTypeAlias) {
       returnType = parseReturnType();
     }
-    SimpleIdentifier name = parseSimpleIdentifier();
+    SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     TypeParameterList typeParameters = null;
     if (_matches(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
     }
     if (_matches(TokenType.SEMICOLON) || _matches(TokenType.EOF)) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
       FormalParameterList parameters = new FormalParameterList(
           _createSyntheticToken(TokenType.OPEN_PAREN),
           null,
           null,
@@ skipping 81 matching lines @@
    *
    *     getter ::=
    *         getterSignature functionBody?
    *
    *     getterSignature ::=
    *         'external'? 'static'? returnType? 'get' identifier
    */
   MethodDeclaration _parseGetter(CommentAndMetadata commentAndMetadata,
       Token externalKeyword, Token staticKeyword, TypeName returnType) {
     Token propertyKeyword = _expectKeyword(Keyword.GET);
-    SimpleIdentifier name = parseSimpleIdentifier();
+    SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     if (_matches(TokenType.OPEN_PAREN) &&
         _tokenMatches(_peek(), TokenType.CLOSE_PAREN)) {
       _reportErrorForCurrentToken(ParserErrorCode.GETTER_WITH_PARAMETERS);
       _advance();
       _advance();
     }
     FunctionBody body = _parseFunctionBody(
         externalKeyword != null || staticKeyword == null,
         ParserErrorCode.STATIC_GETTER_WITHOUT_BODY,
         false);
@@ skipping 65 matching lines @@
     StringLiteral libraryUri = _parseUri();
     List<Configuration> configurations = _parseConfigurations();
     Token deferredToken = null;
     Token asToken = null;
     SimpleIdentifier prefix = null;
     if (_matchesKeyword(Keyword.DEFERRED)) {
       deferredToken = getAndAdvance();
     }
     if (_matchesKeyword(Keyword.AS)) {
       asToken = getAndAdvance();
-      prefix = parseSimpleIdentifier();
+      prefix = parseSimpleIdentifier(isDeclaration: true);
     } else if (deferredToken != null) {
       _reportErrorForCurrentToken(
           ParserErrorCode.MISSING_PREFIX_IN_DEFERRED_IMPORT);
     } else if (!_matches(TokenType.SEMICOLON) &&
         !_matchesString(_SHOW) &&
         !_matchesString(_HIDE)) {
       Token nextToken = _peek();
       if (_tokenMatchesKeyword(nextToken, Keyword.AS) ||
           _tokenMatchesString(nextToken, _SHOW) ||
           _tokenMatchesString(nextToken, _HIDE)) {
         _reportErrorForCurrentToken(
             ParserErrorCode.UNEXPECTED_TOKEN, [_currentToken]);
         _advance();
         if (_matchesKeyword(Keyword.AS)) {
           asToken = getAndAdvance();
-          prefix = parseSimpleIdentifier();
+          prefix = parseSimpleIdentifier(isDeclaration: true);
         }
       }
     }
     List<Combinator> combinators = _parseCombinators();
     Token semicolon = _expect(TokenType.SEMICOLON);
     return new ImportDirective(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         importKeyword,
         libraryUri,
@@ skipping 287 matching lines @@
    *
    *     functionDeclaration ::=
    *         'external'? 'static'? functionSignature functionBody
    *       | 'external'? functionSignature ';'
    */
   MethodDeclaration _parseMethodDeclarationAfterReturnType(
       CommentAndMetadata commentAndMetadata,
       Token externalKeyword,
       Token staticKeyword,
       TypeName returnType) {
-    SimpleIdentifier methodName = parseSimpleIdentifier();
+    SimpleIdentifier methodName = parseSimpleIdentifier(isDeclaration: true);
     TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
     FormalParameterList parameters;
     if (!_matches(TokenType.OPEN_PAREN) &&
         (_matches(TokenType.OPEN_CURLY_BRACKET) ||
             _matches(TokenType.FUNCTION))) {
       _reportErrorForToken(
           ParserErrorCode.MISSING_METHOD_PARAMETERS, _currentToken.previous);
       parameters = new FormalParameterList(
           _createSyntheticToken(TokenType.OPEN_PAREN),
           null,
@@ skipping 342 matching lines @@
       operatorKeyword = getAndAdvance();
     } else {
       _reportErrorForToken(
           ParserErrorCode.MISSING_KEYWORD_OPERATOR, _currentToken);
       operatorKeyword = _createSyntheticKeyword(Keyword.OPERATOR);
     }
     if (!_currentToken.isUserDefinableOperator) {
       _reportErrorForCurrentToken(
           ParserErrorCode.NON_USER_DEFINABLE_OPERATOR, [_currentToken.lexeme]);
     }
-    SimpleIdentifier name = new SimpleIdentifier(getAndAdvance());
+    SimpleIdentifier name =
+        new SimpleIdentifier(getAndAdvance(), isDeclaration: true);
     if (_matches(TokenType.EQ)) {
       Token previous = _currentToken.previous;
       if ((_tokenMatches(previous, TokenType.EQ_EQ) ||
               _tokenMatches(previous, TokenType.BANG_EQ)) &&
           _currentToken.offset == previous.offset + 2) {
         _reportErrorForCurrentToken(ParserErrorCode.INVALID_OPERATOR,
             ["${previous.lexeme}${_currentToken.lexeme}"]);
         _advance();
       }
     }
@@ skipping 364 matching lines @@
    *
    *     setter ::=
    *         setterSignature functionBody?
    *
    *     setterSignature ::=
    *         'external'? 'static'? returnType? 'set' identifier formalParameterList
    */
   MethodDeclaration _parseSetter(CommentAndMetadata commentAndMetadata,
       Token externalKeyword, Token staticKeyword, TypeName returnType) {
     Token propertyKeyword = _expectKeyword(Keyword.SET);
-    SimpleIdentifier name = parseSimpleIdentifier();
+    SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body = _parseFunctionBody(
         externalKeyword != null || staticKeyword == null,
         ParserErrorCode.STATIC_SETTER_WITHOUT_BODY,
         false);
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_SETTER_WITH_BODY);
     }
     return new MethodDeclaration(
@@ skipping 301 matching lines @@
       }
       Token catchKeyword = null;
       Token leftParenthesis = null;
       SimpleIdentifier exceptionParameter = null;
       Token comma = null;
       SimpleIdentifier stackTraceParameter = null;
       Token rightParenthesis = null;
       if (_matchesKeyword(Keyword.CATCH)) {
         catchKeyword = getAndAdvance();
         leftParenthesis = _expect(TokenType.OPEN_PAREN);
-        exceptionParameter = parseSimpleIdentifier();
+        exceptionParameter = parseSimpleIdentifier(isDeclaration: true);
         if (_matches(TokenType.COMMA)) {
           comma = getAndAdvance();
-          stackTraceParameter = parseSimpleIdentifier();
+          stackTraceParameter = parseSimpleIdentifier(isDeclaration: true);
         }
         rightParenthesis = _expect(TokenType.CLOSE_PAREN);
       }
       Block catchBody = parseBlock();
       catchClauses.add(new CatchClause(
           onKeyword,
           exceptionType,
           catchKeyword,
           leftParenthesis,
           exceptionParameter,
@@ skipping 212 matching lines @@
   VariableDeclaration _parseVariableDeclaration() {
     // TODO(paulberry): prior to the fix for bug 23204, we permitted
     // annotations before variable declarations (e.g. "String @deprecated s;").
     // Although such constructions are prohibited by the spec, we may want to
     // consider handling them anyway to allow for better parser recovery in the
     // event that the user erroneously tries to use them.  However, as a
     // counterargument, this would likely degrade parser recovery in the event
     // of a construct like "class C { int @deprecated foo() {} }" (i.e. the
     // user is in the middle of inserting "int bar;" prior to
     // "@deprecated foo() {}").
-    SimpleIdentifier name = parseSimpleIdentifier();
+    SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     Token equals = null;
     Expression initializer = null;
     if (_matches(TokenType.EQ)) {
       equals = getAndAdvance();
       initializer = parseExpression2();
     }
     return new VariableDeclaration(name, equals, initializer);
   }
 
   /**
@@ skipping 1807 matching lines @@
    */
   const ParserErrorCode(String name, String message, [String correction])
       : super(name, message, correction);
 
   @override
   ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
 
   @override
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
 }