Clean up references in comments

pkg/analyzer/lib/src/generated/html.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.html;
 
 import 'dart:collection';
@@ skipping 1641 matching lines @@
    */
   Token _insertSyntheticToken(TokenType type) {
     Token token = new Token.con2(type, _currentToken.offset, "");
     _currentToken.previous.setNext(token);
     token.setNext(_currentToken);
     return token;
   }
 
   /**
    * Parse the token stream for an attribute. This method advances the current token over the
-   * attribute, but should not be called if the [currentToken] is not [TokenType#TAG].
+   * attribute, but should not be called if the [currentToken] is not [TokenType.TAG].
    *
    * @return the attribute (not `null`)
    */
   XmlAttributeNode _parseAttribute() {
     // Assume the current token is a tag
     Token name = _currentToken;
     _currentToken = _currentToken.next;
     // Equals sign
     Token equals;
     if (_currentToken.type == TokenType.EQ) {
@@ skipping 10 matching lines @@
       _currentToken = _currentToken.next;
     } else {
       _reportUnexpectedToken();
       value = _insertSyntheticToken(TokenType.STRING);
     }
     return createAttributeNode(name, equals, value);
   }
 
   /**
    * Parse the stream for a sequence of attributes. This method advances the current token to the
-   * next [TokenType#GT], [TokenType#SLASH_GT], or [TokenType#EOF].
+   * next [TokenType.GT], [TokenType.SLASH_GT], or [TokenType.EOF].
    *
    * @return a collection of zero or more attributes (not `null`, contains no `null`s)
    */
   List<XmlAttributeNode> _parseAttributes() {
     TokenType type = _currentToken.type;
     if (type == TokenType.GT || type == TokenType.SLASH_GT || type == TokenType.EOF) {
       return XmlTagNode.NO_ATTRIBUTES;
     }
     List<XmlAttributeNode> attributes = new List<XmlAttributeNode>();
     while (type != TokenType.GT && type != TokenType.SLASH_GT && type != TokenType.EOF) {
       if (type == TokenType.TAG) {
         attributes.add(_parseAttribute());
       } else {
         _reportUnexpectedToken();
         _currentToken = _currentToken.next;
       }
       type = _currentToken.type;
     }
     return attributes;
   }
 
   /**
    * Parse the stream for a sequence of tag nodes existing within a parent tag node. This method
-   * advances the current token to the next [TokenType#LT_SLASH] or [TokenType#EOF].
+   * advances the current token to the next [TokenType.LT_SLASH] or [TokenType.EOF].
    *
    * @return a list of nodes (not `null`, contains no `null`s)
    */
   List<XmlTagNode> _parseChildTagNodes() {
     TokenType type = _currentToken.type;
     if (type == TokenType.LT_SLASH || type == TokenType.EOF) {
       return XmlTagNode.NO_TAG_NODES;
     }
     List<XmlTagNode> nodes = new List<XmlTagNode>();
     while (type != TokenType.LT_SLASH && type != TokenType.EOF) {
       if (type == TokenType.LT) {
         nodes.add(_parseTagNode());
       } else if (type == TokenType.COMMENT) {
         // ignored token
         _currentToken = _currentToken.next;
       } else {
         _reportUnexpectedToken();
         _currentToken = _currentToken.next;
       }
       type = _currentToken.type;
     }
     return nodes;
   }
 
   /**
    * Parse the token stream for the next tag node. This method advances current token over the
-   * parsed tag node, but should only be called if the current token is [TokenType#LT]
+   * parsed tag node, but should only be called if the current token is [TokenType.LT]
    *
    * @return the tag node or `null` if none found
    */
   XmlTagNode _parseTagNode() {
-    // Assume that the current node is a tag node start TokenType#LT
+    // Assume that the current node is a tag node start TokenType.LT
     Token nodeStart = _currentToken;
     _currentToken = _currentToken.next;
     // Get the tag or create a synthetic tag and report an error
     Token tag;
     if (_currentToken.type == TokenType.TAG) {
       tag = _currentToken;
       _currentToken = _currentToken.next;
     } else {
       _reportUnexpectedToken();
       tag = _insertSyntheticToken(TokenType.TAG);
@@ skipping 64 matching lines @@
    * Constant representing empty list of attributes.
    */
   static List<XmlAttributeNode> NO_ATTRIBUTES = new UnmodifiableListView(new List<XmlAttributeNode>());
 
   /**
    * Constant representing empty list of tag nodes.
    */
   static List<XmlTagNode> NO_TAG_NODES = new UnmodifiableListView(new List<XmlTagNode>());
 
   /**
-   * The starting [TokenType#LT] token (not `null`).
+   * The starting [TokenType.LT] token (not `null`).
    */
   final Token nodeStart;
 
   /**
-   * The [TokenType#TAG] token after the starting '&lt;' (not `null`).
+   * The [TokenType.TAG] token after the starting '&lt;' (not `null`).
    */
   final Token _tag;
 
   /**
    * The attributes contained by the receiver (not `null`, contains no `null`s).
    */
   List<XmlAttributeNode> _attributes;
 
   /**
-   * The [TokenType#GT] or [TokenType#SLASH_GT] token after the attributes (not
+   * The [TokenType.GT] or [TokenType.SLASH_GT] token after the attributes (not
    * `null`). The token may be the same token as [nodeEnd] if there are no child
    * [tagNodes].
    */
   final Token attributeEnd;
 
   /**
    * The tag nodes contained in the receiver (not `null`, contains no `null`s).
    */
   List<XmlTagNode> _tagNodes;
 
   /**
    * The token (not `null`) after the content, which may be
-   * * (1) [TokenType#LT_SLASH] for nodes with open and close tags, or
-   * * (2) the [TokenType#LT] nodeStart of the next sibling node if this node is self
-   * closing or the attributeEnd is [TokenType#SLASH_GT], or
-   * * (3) [TokenType#EOF] if the node does not have a closing tag and is the last node in
-   * the stream [TokenType#LT_SLASH] token after the content, or `null` if there is no
-   * content and the attributes ended with [TokenType#SLASH_GT].
+   * * (1) [TokenType.LT_SLASH] for nodes with open and close tags, or
+   * * (2) the [TokenType.LT] nodeStart of the next sibling node if this node is self
+   * closing or the attributeEnd is [TokenType.SLASH_GT], or
+   * * (3) [TokenType.EOF] if the node does not have a closing tag and is the last node in
+   * the stream [TokenType.LT_SLASH] token after the content, or `null` if there is no
+   * content and the attributes ended with [TokenType.SLASH_GT].
    */
   final Token contentEnd;
 
   /**
-   * The closing [TokenType#TAG] after the child elements or `null` if there is no
-   * content and the attributes ended with [TokenType#SLASH_GT]
+   * The closing [TokenType.TAG] after the child elements or `null` if there is no
+   * content and the attributes ended with [TokenType.SLASH_GT]
    */
   final Token closingTag;
 
   /**
-   * The ending [TokenType#GT] or [TokenType#SLASH_GT] token (not `null`).
+   * The ending [TokenType.GT] or [TokenType.SLASH_GT] token (not `null`).
    */
   final Token nodeEnd;
 
   /**
    * The expressions that are embedded in the tag's content.
    */
   List<XmlExpression> expressions = XmlExpression.EMPTY_ARRAY;
 
   /**
    * Construct a new instance representing an XML or HTML element
    *
-   * @param nodeStart the starting [TokenType#LT] token (not `null`)
-   * @param tag the [TokenType#TAG] token after the starting '&lt;' (not `null`).
+   * @param nodeStart the starting [TokenType.LT] token (not `null`)
+   * @param tag the [TokenType.TAG] token after the starting '&lt;' (not `null`).
    * @param attributes the attributes associated with this element or [NO_ATTRIBUTES] (not
    *          `null`, contains no `null`s)
-   * @param attributeEnd The [TokenType#GT] or [TokenType#SLASH_GT] token after the
+   * @param attributeEnd The [TokenType.GT] or [TokenType.SLASH_GT] token after the
    *          attributes (not `null`). The token may be the same token as [nodeEnd] if
    *          there are no child [tagNodes].
    * @param tagNodes child tag nodes of the receiver or [NO_TAG_NODES] (not `null`,
    *          contains no `null`s)
    * @param contentEnd the token (not `null`) after the content, which may be
-   *          * (1) [TokenType#LT_SLASH] for nodes with open and close tags, or
-   *          * (2) the [TokenType#LT] nodeStart of the next sibling node if this node is
-   *          self closing or the attributeEnd is [TokenType#SLASH_GT], or
-   *          * (3) [TokenType#EOF] if the node does not have a closing tag and is the last
-   *          node in the stream [TokenType#LT_SLASH] token after the content, or `null`
-   *          if there is no content and the attributes ended with [TokenType#SLASH_GT].
-   * @param closingTag the closing [TokenType#TAG] after the child elements or `null` if
-   *          there is no content and the attributes ended with [TokenType#SLASH_GT]
-   * @param nodeEnd the ending [TokenType#GT] or [TokenType#SLASH_GT] token (not
+   *          * (1) [TokenType.LT_SLASH] for nodes with open and close tags, or
+   *          * (2) the [TokenType.LT] nodeStart of the next sibling node if this node is
+   *          self closing or the attributeEnd is [TokenType.SLASH_GT], or
+   *          * (3) [TokenType.EOF] if the node does not have a closing tag and is the last
+   *          node in the stream [TokenType.LT_SLASH] token after the content, or `null`
+   *          if there is no content and the attributes ended with [TokenType.SLASH_GT].
+   * @param closingTag the closing [TokenType.TAG] after the child elements or `null` if
+   *          there is no content and the attributes ended with [TokenType.SLASH_GT]
+   * @param nodeEnd the ending [TokenType.GT] or [TokenType.SLASH_GT] token (not
    *          `null`)
    */
   XmlTagNode(this.nodeStart, this._tag, List<XmlAttributeNode> attributes, this.attributeEnd, List<XmlTagNode> tagNodes, this.contentEnd, this.closingTag, this.nodeEnd) {
     this._attributes = becomeParentOfAll(attributes, ifEmpty: NO_ATTRIBUTES);
     this._tagNodes = becomeParentOfAll(tagNodes, ifEmpty: NO_TAG_NODES);
   }
 
   @override
   accept(XmlVisitor visitor) => visitor.visitXmlTagNode(this);
 
@@ skipping 16 matching lines @@
    * Answer the receiver's attributes. Callers should not manipulate the returned list to edit the
    * AST structure.
    *
    * @return the attributes (not `null`, contains no `null`s)
    */
   List<XmlAttributeNode> get attributes => _attributes;
 
   /**
    * Find the attribute with the given name (see [getAttribute] and answer the lexeme
    * for the attribute's value token without the leading and trailing quotes (see
-   * [XmlAttributeNode#getText]).
+   * [XmlAttributeNode.getText]).
    *
    * @param name the attribute name
    * @return the attribute text or `null` if no matching attribute is found
    */
   String getAttributeText(String name) {
     XmlAttributeNode attribute = getAttribute(name);
     return attribute != null ? attribute.text : null;
   }
 
   @override
@@ skipping 58 matching lines @@
 
   /**
    * Answer the tag nodes contained in the receiver. Callers should not manipulate the returned list
    * to edit the AST structure.
    *
    * @return the children (not `null`, contains no `null`s)
    */
   List<XmlTagNode> get tagNodes => _tagNodes;
 
   /**
-   * Answer the [TokenType#TAG] token after the starting '&lt;'.
+   * Answer the [TokenType.TAG] token after the starting '&lt;'.
    *
    * @return the token (not `null`)
    */
   Token get tagToken => _tag;
 
   @override
   void visitChildren(XmlVisitor visitor) {
     for (XmlAttributeNode node in _attributes) {
       node.accept(visitor);
     }
     for (XmlTagNode node in _tagNodes) {
       node.accept(visitor);
     }
   }
 }
 
 /**
  * The interface `XmlVisitor` defines the behavior of objects that can be used to visit an
  * [XmlNode] structure.
  */
 abstract class XmlVisitor<R> {
   R visitHtmlScriptTagNode(HtmlScriptTagNode node);
 
   R visitHtmlUnit(HtmlUnit htmlUnit);
 
   R visitXmlAttributeNode(XmlAttributeNode xmlAttributeNode);
 
   R visitXmlTagNode(XmlTagNode xmlTagNode);
 }