Clean up references in comments

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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
 import 'dart:collection';
@@ skipping 2980 matching lines @@
    */
   void _ensureAssignable(Expression expression) {
     if (expression != null && !expression.isAssignable) {
       _reportErrorForCurrentToken(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, []);
     }
   }
 
   /**
    * If the current token has the expected type, return it after advancing to the next token.
    * Otherwise report an error and return the current token without advancing. Note that the method
-   * [expectGt] should be used if the argument to this method would be [TokenType#GT]
-   * .
+   * [_expectGt] should be used if the argument to this method would be [TokenType.GT].
    *
    * @param type the type of token that is expected
    * @return the token that matched the given type
    */
   Token _expect(TokenType type) {
     if (_matches(type)) {
       return andAdvance;
     }
     // Remove uses of this method in favor of matches?
     // Pass in the error code to use to report the error?
     if (type == TokenType.SEMICOLON) {
       _reportErrorForToken(ParserErrorCode.EXPECTED_TOKEN, _currentToken.previous, [type.lexeme]);
     } else {
       _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_TOKEN, [type.lexeme]);
     }
     return _currentToken;
   }
 
   /**
-   * If the current token has the type [TokenType#GT], return it after advancing to the next
+   * If the current token has the type [TokenType.GT], return it after advancing to the next
    * token. Otherwise report an error and return the current token without advancing.
    *
    * @return the token that matched the given type
    */
   Token _expectGt() {
     if (_matchesGt()) {
       return andAdvance;
     }
     _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_TOKEN, [TokenType.GT.lexeme]);
     return _currentToken;
@@ skipping 419 matching lines @@
   /**
    * Increments the error reporting lock level. If level is more than `0`, then
    * [reportError] wont report any error.
    */
   void _lockErrorListener() {
     _errorListenerLock++;
   }
 
   /**
    * Return `true` if the current token has the given type. Note that the method
-   * [matchesGt] should be used if the argument to this method would be
-   * [TokenType#GT].
+   * [_matchesGt] should be used if the argument to this method would be
+   * [TokenType.GT].
    *
    * @param type the type of token that can optionally appear in the current location
    * @return `true` if the current token has the given type
    */
   bool _matches(TokenType type) => _currentToken.type == type;
 
   /**
-   * Return `true` if the current token has a type of [TokenType#GT]. Note that this
+   * Return `true` if the current token has a type of [TokenType.GT]. Note that this
    * method, unlike other variants, will modify the token stream if possible to match desired type.
    * In particular, if the next token is either a '>>' or '>>>', the token stream will be re-written
    * and `true` will be returned.
    *
-   * @return `true` if the current token has a type of [TokenType#GT]
+   * @return `true` if the current token has a type of [TokenType.GT]
    */
   bool _matchesGt() {
     TokenType currentType = _currentToken.type;
     if (currentType == TokenType.GT) {
       return true;
     } else if (currentType == TokenType.GT_GT) {
       int offset = _currentToken.offset;
       Token first = new Token(TokenType.GT, offset);
       Token second = new Token(TokenType.GT, offset + 1);
       second.setNext(_currentToken.next);
@@ skipping 45 matching lines @@
    * Return `true` if the current token matches the given identifier.
    *
    * @param identifier the identifier that can optionally appear in the current location
    * @return `true` if the current token matches the given identifier
    */
   bool _matchesString(String identifier) => _currentToken.type == TokenType.IDENTIFIER && _currentToken.lexeme == identifier;
 
   /**
    * If the current token has the given type, then advance to the next token and return `true`
    * . Otherwise, return `false` without advancing. This method should not be invoked with an
-   * argument value of [TokenType#GT].
+   * argument value of [TokenType.GT].
    *
    * @param type the type of token that can optionally appear in the current location
    * @return `true` if the current token has the given type
    */
   bool _optional(TokenType type) {
     if (_matches(type)) {
       _advance();
       return true;
     }
     return false;
@@ skipping 6229 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }