Fix for translation of \!= to \!identical(), but use == and \!= for Enum.

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';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'error.dart' show AnalysisErrorListener;
 import 'scanner.dart' as sc show Scanner, SubSequenceReader, Token;
 import 'parser.dart' show Parser;
 import 'ast.dart';
 import 'element.dart';
 import 'engine.dart' show AnalysisEngine, AngularHtmlUnitResolver, ExpressionVisitor;
 
 /**
  * Instances of the class `Token` represent a token that was scanned from the input. Each
  * token knows which token follows it, acting as the head of a linked list of tokens.
  */
 class Token {
   /**
    * The offset from the beginning of the file to the first character in the token.
    */
-  int _offset = 0;
+  final int offset;
 
   /**
    * The previous token in the token stream.
    */
   Token previous;
 
   /**
    * The next token in the token stream.
    */
   Token _next;
 
   /**
    * The type of the token.
    */
-  TokenType _type;
+  final TokenType type;
 
   /**
    * The lexeme represented by this token.
    */
   String _value;
 
   /**
    * Initialize a newly created token.
    *
    * @param type the token type (not `null`)
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   Token.con1(TokenType type, int offset) : this.con2(type, offset, type.lexeme);
 
   /**
    * Initialize a newly created token.
    *
    * @param type the token type (not `null`)
    * @param offset the offset from the beginning of the file to the first character in the token
    * @param value the lexeme represented by this token (not `null`)
    */
-  Token.con2(TokenType type, int offset, String value) {
-    this._type = type;
+  Token.con2(this.type, this.offset, String value) {
     this._value = StringUtilities.intern(value);
-    this._offset = offset;
   }
 
   /**
    * Return the offset from the beginning of the file to the character after last character of the
    * token.
    *
    * @return the offset from the beginning of the file to the first character after last character
    *         of the token
    */
-  int get end => _offset + length;
+  int get end => offset + length;
 
   /**
    * Return the number of characters in the node's source range.
    *
    * @return the number of characters in the node's source range
    */
   int get length => lexeme.length;
 
   /**
    * Return the lexeme that represents this token.
    *
    * @return the lexeme (not `null`)
    */
   String get lexeme => _value;
 
   /**
    * Return the next token in the token stream.
    *
    * @return the next token in the token stream
    */
   Token get next => _next;
 
   /**
-   * Return the offset from the beginning of the file to the first character in the token.
-   *
-   * @return the offset from the beginning of the file to the first character in the token
-   */
-  int get offset => _offset;
-
-  /**
-   * Answer the token type for the receiver.
-   *
-   * @return the token type (not `null`)
-   */
-  TokenType get type => _type;
-
-  /**
    * Return `true` if this token is a synthetic token. A synthetic token is a token that was
    * introduced by the parser in order to recover from an error in the code. Synthetic tokens always
    * have a length of zero (`0`).
    *
    * @return `true` if this token is a synthetic token
    */
   bool get isSynthetic => length == 0;
 
   /**
    * Set the next token in the token stream to the given token. This has the side-effect of setting
@@ skipping 10 matching lines @@
 
   @override
   String toString() => lexeme;
 }
 
 /**
  * Implementation of [XmlExpression] for an [Expression] embedded without any wrapping
  * characters.
  */
 class RawXmlExpression extends XmlExpression {
-  Expression expression;
+  final Expression expression;
 
-  RawXmlExpression(Expression expression) {
-    this.expression = expression;
-  }
+  RawXmlExpression(this.expression);
 
   @override
   int get end => expression.end;
 
   @override
   int get length => expression.length;
 
   @override
   int get offset => expression.offset;
 
@@ skipping 452 matching lines @@
   }
 
   /**
    * This method exists for debugging purposes only.
    */
   String _buildRecursiveStructureMessage(XmlNode newParent) {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("Attempt to create recursive structure: ");
     XmlNode current = newParent;
     while (current != null) {
-      if (current != newParent) {
+      if (!identical(current, newParent)) {
         builder.append(" -> ");
       }
       if (identical(current, this)) {
         builder.appendChar(0x2A);
         _appendIdentifier(builder, current);
         builder.appendChar(0x2A);
       } else {
         _appendIdentifier(builder, current);
       }
       current = current.parent;
@@ skipping 42 matching lines @@
 /**
  * The abstract class `AbstractScanner` implements a scanner for HTML code. Subclasses are
  * required to implement the interface used to access the characters being scanned.
  */
 abstract class AbstractScanner {
   static List<String> _NO_PASS_THROUGH_ELEMENTS = <String> [];
 
   /**
    * The source being scanned.
    */
-  Source source;
+  final Source source;
 
   /**
    * The token pointing to the head of the linked list of tokens.
    */
   Token _tokens;
 
   /**
    * The last token that was scanned.
    */
   Token _tail;
 
   /**
    * A list containing the offsets of the first character of each line in the source code.
    */
   List<int> _lineStarts = new List<int>();
 
   /**
    * An array of element tags for which the content between tags should be consider a single token.
    */
   List<String> _passThroughElements = _NO_PASS_THROUGH_ELEMENTS;
 
   /**
    * Initialize a newly created scanner.
    *
    * @param source the source being scanned
    */
-  AbstractScanner(Source source) {
-    this.source = source;
+  AbstractScanner(this.source) {
     _tokens = new Token.con1(TokenType.EOF, -1);
     _tokens.setNext(_tokens);
     _tail = _tokens;
     recordStartOfLine();
   }
 
   /**
    * Return an array containing the offsets of the first character of each line in the source code.
    *
    * @return an array containing the offsets of the first character of each line in the source code
@@ skipping 269 matching lines @@
 }
 
 /**
  * Instances of the class `StringScanner` implement a scanner that reads from a string. The
  * scanning logic is in the superclass.
  */
 class StringScanner extends AbstractScanner {
   /**
    * The string from which characters will be read.
    */
-  String _string;
+  final String _string;
 
   /**
    * The number of characters in the string.
    */
   int _stringLength = 0;
 
   /**
    * The index, relative to the string, of the last character that was read.
    */
   int _charOffset = 0;
 
   /**
    * Initialize a newly created scanner to scan the characters in the given string.
    *
    * @param source the source being scanned
    * @param string the string from which characters will be read
    */
-  StringScanner(Source source, String string) : super(source) {
-    this._string = string;
-    this._stringLength = string.length;
+  StringScanner(Source source, this._string) : super(source) {
+    this._stringLength = _string.length;
     this._charOffset = -1;
   }
 
   @override
   int get offset => _charOffset;
 
   void set offset(int offset) {
     _charOffset = offset;
   }
 
@@ skipping 19 matching lines @@
 }
 
 /**
  * Instances of the class `ToSourceVisitor` write a source representation of a visited XML
  * node (and all of it's children) to a writer.
  */
 class ToSourceVisitor implements XmlVisitor<Object> {
   /**
    * The writer to which the source is to be written.
    */
-  PrintWriter _writer;
+  final PrintWriter _writer;
 
   /**
    * Initialize a newly created visitor to write source code representing the visited nodes to the
    * given writer.
    *
    * @param writer the writer to which the source is to be written
    */
-  ToSourceVisitor(PrintWriter writer) {
-    this._writer = writer;
-  }
+  ToSourceVisitor(this._writer);
 
   @override
   Object visitHtmlScriptTagNode(HtmlScriptTagNode node) => visitXmlTagNode(node);
 
   @override
   Object visitHtmlUnit(HtmlUnit node) {
     for (XmlTagNode child in node.tagNodes) {
       _visit(child);
     }
     return null;
@@ skipping 51 matching lines @@
 }
 
 /**
  * The enumeration `TokenType` defines the types of tokens that can be returned by the
  * scanner.
  */
 class TokenType extends Enum<TokenType> {
   /**
    * The type of the token that marks the end of the input.
    */
-  static final TokenType EOF = new TokenType_EOF('EOF', 0, "");
+  static const TokenType EOF = const TokenType_EOF('EOF', 0, "");
 
-  static final TokenType EQ = new TokenType('EQ', 1, "=");
+  static const TokenType EQ = const TokenType('EQ', 1, "=");
 
-  static final TokenType GT = new TokenType('GT', 2, ">");
+  static const TokenType GT = const TokenType('GT', 2, ">");
 
-  static final TokenType LT_SLASH = new TokenType('LT_SLASH', 3, "</");
+  static const TokenType LT_SLASH = const TokenType('LT_SLASH', 3, "</");
 
-  static final TokenType LT = new TokenType('LT', 4, "<");
+  static const TokenType LT = const TokenType('LT', 4, "<");
 
-  static final TokenType SLASH_GT = new TokenType('SLASH_GT', 5, "/>");
+  static const TokenType SLASH_GT = const TokenType('SLASH_GT', 5, "/>");
 
-  static final TokenType COMMENT = new TokenType('COMMENT', 6, null);
+  static const TokenType COMMENT = const TokenType('COMMENT', 6, null);
 
-  static final TokenType DECLARATION = new TokenType('DECLARATION', 7, null);
+  static const TokenType DECLARATION = const TokenType('DECLARATION', 7, null);
 
-  static final TokenType DIRECTIVE = new TokenType('DIRECTIVE', 8, null);
+  static const TokenType DIRECTIVE = const TokenType('DIRECTIVE', 8, null);
 
-  static final TokenType STRING = new TokenType('STRING', 9, null);
+  static const TokenType STRING = const TokenType('STRING', 9, null);
 
-  static final TokenType TAG = new TokenType('TAG', 10, null);
+  static const TokenType TAG = const TokenType('TAG', 10, null);
 
-  static final TokenType TEXT = new TokenType('TEXT', 11, null);
+  static const TokenType TEXT = const TokenType('TEXT', 11, null);
 
-  static final List<TokenType> values = [
+  static const List<TokenType> values = const [
       EOF,
       EQ,
       GT,
       LT_SLASH,
       LT,
       SLASH_GT,
       COMMENT,
       DECLARATION,
       DIRECTIVE,
       STRING,
       TAG,
       TEXT];
 
   /**
    * The lexeme that defines this type of token, or `null` if there is more than one possible
    * lexeme for this type of token.
    */
-  String lexeme;
+  final String lexeme;
 
-  TokenType(String name, int ordinal, String lexeme) : super(name, ordinal) {
-    this.lexeme = lexeme;
-  }
+  const TokenType(String name, int ordinal, this.lexeme) : super(name, ordinal);
 }
 
 class TokenType_EOF extends TokenType {
-  TokenType_EOF(String name, int ordinal, String arg0) : super(name, ordinal, arg0);
+  const TokenType_EOF(String name, int ordinal, String arg0) : super(name, ordinal, arg0);
 
   @override
   String toString() => "-eof-";
 }
 
 /**
  * Instances of `XmlAttributeNode` represent name/value pairs owned by an [XmlTagNode].
  */
 class XmlAttributeNode extends XmlNode {
-  Token _name;
+  final Token _name;
 
-  Token equals;
+  final Token equals;
 
-  Token _value;
+  final Token _value;
 
   List<XmlExpression> expressions = XmlExpression.EMPTY_ARRAY;
 
   /**
    * Construct a new instance representing an XML attribute.
    *
    * @param name the name token (not `null`). This may be a zero length token if the attribute
    *          is badly formed.
    * @param equals the equals sign or `null` if none
    * @param value the value token (not `null`)
    */
-  XmlAttributeNode(Token name, Token equals, Token value) {
-    this._name = name;
-    this.equals = equals;
-    this._value = value;
-  }
+  XmlAttributeNode(this._name, this.equals, this._value);
 
   @override
   accept(XmlVisitor visitor) => visitor.visitXmlAttributeNode(this);
 
   @override
   Token get beginToken => _name;
 
   @override
   Token get endToken => _value;
 
@@ skipping 129 matching lines @@
 }
 
 /**
  * Instances of the class `XmlParser` are used to parse tokens into a AST structure comprised
  * of [XmlNode]s.
  */
 class XmlParser {
   /**
    * The source being parsed.
    */
-  Source source;
+  final Source source;
 
   /**
    * The next token to be parsed.
    */
   Token _currentToken;
 
   /**
    * Construct a parser for the specified source.
    *
    * @param source the source being parsed
    */
-  XmlParser(Source source) {
-    this.source = source;
-  }
+  XmlParser(this.source);
 
   /**
    * Create a node representing an attribute.
    *
    * @param name the name of the attribute
    * @param equals the equals sign, or `null` if there is no value
    * @param value the value of the attribute
    * @return the node that was created
    */
   XmlAttributeNode createAttributeNode(Token name, Token equals, Token value) => new XmlAttributeNode(name, equals, value);
@@ skipping 26 matching lines @@
    * Parse the entire token stream and in the process, advance the current token to the end of the
    * token stream.
    *
    * @return the list of tag nodes found (not `null`, contains no `null`)
    */
   List<XmlTagNode> parseTopTagNodes(Token firstToken) {
     _currentToken = firstToken;
     List<XmlTagNode> tagNodes = new List<XmlTagNode>();
     TokenType type = _currentToken.type;
     while (type != TokenType.EOF) {
-      if (identical(type, TokenType.LT)) {
+      if (type == TokenType.LT) {
         tagNodes.add(_parseTagNode());
-      } else if (identical(type, TokenType.DECLARATION) || identical(type, TokenType.DIRECTIVE) || identical(type, TokenType.COMMENT)) {
+      } else if (type == TokenType.DECLARATION || type == TokenType.DIRECTIVE || type == TokenType.COMMENT) {
         // ignored tokens
         _currentToken = _currentToken.next;
       } else {
         _reportUnexpectedToken();
         _currentToken = _currentToken.next;
       }
       type = _currentToken.type;
     }
     return tagNodes;
   }
@@ skipping 23 matching lines @@
    * 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 (identical(_currentToken.type, TokenType.EQ)) {
+    if (_currentToken.type == TokenType.EQ) {
       equals = _currentToken;
       _currentToken = _currentToken.next;
     } else {
       _reportUnexpectedToken();
       equals = _insertSyntheticToken(TokenType.EQ);
     }
     // String value
     Token value;
-    if (identical(_currentToken.type, TokenType.STRING)) {
+    if (_currentToken.type == TokenType.STRING) {
       value = _currentToken;
       _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].
    *
    * @return a collection of zero or more attributes (not `null`, contains no `null`s)
    */
   List<XmlAttributeNode> _parseAttributes() {
     TokenType type = _currentToken.type;
-    if (identical(type, TokenType.GT) || identical(type, TokenType.SLASH_GT) || identical(type, TokenType.EOF)) {
+    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 (identical(type, TokenType.TAG)) {
+      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].
    *
    * @return a list of nodes (not `null`, contains no `null`s)
    */
   List<XmlTagNode> _parseChildTagNodes() {
     TokenType type = _currentToken.type;
-    if (identical(type, TokenType.LT_SLASH) || identical(type, TokenType.EOF)) {
+    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 (identical(type, TokenType.LT)) {
+      if (type == TokenType.LT) {
         nodes.add(_parseTagNode());
-      } else if (identical(type, TokenType.COMMENT)) {
+      } 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]
    *
    * @return the tag node or `null` if none found
    */
   XmlTagNode _parseTagNode() {
     // 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 (identical(_currentToken.type, TokenType.TAG)) {
+    if (_currentToken.type == TokenType.TAG) {
       tag = _currentToken;
       _currentToken = _currentToken.next;
     } else {
       _reportUnexpectedToken();
       tag = _insertSyntheticToken(TokenType.TAG);
     }
     // Parse the attributes
     List<XmlAttributeNode> attributes = _parseAttributes();
     // Token ending attribute list
     Token attributeEnd;
-    if (identical(_currentToken.type, TokenType.GT) || identical(_currentToken.type, TokenType.SLASH_GT)) {
+    if (_currentToken.type == TokenType.GT || _currentToken.type == TokenType.SLASH_GT) {
       attributeEnd = _currentToken;
       _currentToken = _currentToken.next;
     } else {
       _reportUnexpectedToken();
       attributeEnd = _insertSyntheticToken(TokenType.SLASH_GT);
     }
     // If the node has no children, then return the node
-    if (identical(attributeEnd.type, TokenType.SLASH_GT) || isSelfClosing(tag)) {
+    if (attributeEnd.type == TokenType.SLASH_GT || isSelfClosing(tag)) {
       return createTagNode(nodeStart, tag, attributes, attributeEnd, XmlTagNode.NO_TAG_NODES, _currentToken, null, attributeEnd);
     }
     // Parse the child tag nodes
     List<XmlTagNode> tagNodes = _parseChildTagNodes();
     // Token ending child tag nodes
     Token contentEnd;
-    if (identical(_currentToken.type, TokenType.LT_SLASH)) {
+    if (_currentToken.type == TokenType.LT_SLASH) {
       contentEnd = _currentToken;
       _currentToken = _currentToken.next;
     } else {
       // TODO (danrubel): handle self closing HTML elements by inserting synthetic tokens
       // but not reporting an error
       _reportUnexpectedToken();
       contentEnd = _insertSyntheticToken(TokenType.LT_SLASH);
     }
     // Closing tag
     Token closingTag;
-    if (identical(_currentToken.type, TokenType.TAG)) {
+    if (_currentToken.type == TokenType.TAG) {
       closingTag = _currentToken;
       _currentToken = _currentToken.next;
     } else {
       _reportUnexpectedToken();
       closingTag = _insertSyntheticToken(TokenType.TAG);
     }
     // Token ending node
     Token nodeEnd;
-    if (identical(_currentToken.type, TokenType.GT)) {
+    if (_currentToken.type == TokenType.GT) {
       nodeEnd = _currentToken;
       _currentToken = _currentToken.next;
     } else {
       _reportUnexpectedToken();
       nodeEnd = _insertSyntheticToken(TokenType.GT);
     }
     return createTagNode(nodeStart, tag, attributes, attributeEnd, tagNodes, contentEnd, closingTag, nodeEnd);
   }
 
   /**
@@ skipping 14 matching lines @@
   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`).
    */
-  Token nodeStart;
+  final Token nodeStart;
 
   /**
    * The [TokenType#TAG] token after the starting '&lt;' (not `null`).
    */
-  Token _tag;
+  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
    * `null`). The token may be the same token as [nodeEnd] if there are no child
    * [tagNodes].
    */
-  Token attributeEnd;
+  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].
    */
-  Token contentEnd;
+  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]
    */
-  Token closingTag;
+  final Token closingTag;
 
   /**
    * The ending [TokenType#GT] or [TokenType#SLASH_GT] token (not `null`).
    */
-  Token nodeEnd;
+  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`)
@@ skipping 10 matching lines @@
    *          * (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(Token nodeStart, Token tag, List<XmlAttributeNode> attributes, Token attributeEnd, List<XmlTagNode> tagNodes, Token contentEnd, Token closingTag, Token nodeEnd) {
-    this.nodeStart = nodeStart;
-    this._tag = tag;
+  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.attributeEnd = attributeEnd;
     this._tagNodes = becomeParentOfAll(tagNodes, ifEmpty: NO_TAG_NODES);
-    this.contentEnd = contentEnd;
-    this.closingTag = closingTag;
-    this.nodeEnd = nodeEnd;
   }
 
   @override
   accept(XmlVisitor visitor) => visitor.visitXmlTagNode(this);
 
   /**
    * Answer the attribute with the specified name.
    *
    * @param name the attribute name
    * @return the attribute or `null` if no matching attribute is found
@@ skipping 43 matching lines @@
     if (identical(token, contentEnd)) {
       return "";
     }
     //TODO (danrubel): handle CDATA and replace HTML character encodings with the actual characters
     String content = token.lexeme;
     token = token.next;
     if (identical(token, contentEnd)) {
       return content;
     }
     JavaStringBuilder buffer = new JavaStringBuilder();
-    while (token != contentEnd) {
+    while (!identical(token, contentEnd)) {
       buffer.append(token.lexeme);
       token = token.next;
     }
     return buffer.toString();
   }
 
   @override
   Token get endToken {
     if (nodeEnd != null) {
       return nodeEnd;
@@ skipping 55 matching lines @@
  */
 class HtmlParser extends XmlParser {
   /**
    * The line information associated with the source being parsed.
    */
   LineInfo _lineInfo;
 
   /**
    * The error listener to which errors will be reported.
    */
-  AnalysisErrorListener _errorListener;
+  final AnalysisErrorListener _errorListener;
 
   static String _APPLICATION_DART_IN_DOUBLE_QUOTES = "\"application/dart\"";
 
   static String _APPLICATION_DART_IN_SINGLE_QUOTES = "'application/dart'";
 
   static String _SCRIPT = "script";
 
   static String _TYPE = "type";
 
   /**
@@ skipping 29 matching lines @@
     scanner.setSourceStart(location.lineNumber, location.columnNumber);
     return scanner.tokenize();
   }
 
   /**
    * Construct a parser for the specified source.
    *
    * @param source the source being parsed
    * @param errorListener the error listener to which errors will be reported
    */
-  HtmlParser(Source source, AnalysisErrorListener errorListener) : super(source) {
-    this._errorListener = errorListener;
-  }
+  HtmlParser(Source source, this._errorListener) : super(source);
 
   /**
    * Parse the given tokens.
    *
    * @param token the first token in the stream of tokens to be parsed
    * @param lineInfo the line information created by the scanner
    * @return the parse result (not `null`)
    */
   HtmlUnit parse(Token token, LineInfo lineInfo) {
     this._lineInfo = lineInfo;
@@ skipping 51 matching lines @@
   }
 }
 
 /**
  * Instances of the class `HtmlUnit` represent the contents of an HTML file.
  */
 class HtmlUnit extends XmlNode {
   /**
    * The first token in the token stream that was parsed to form this HTML unit.
    */
-  Token beginToken;
+  final Token beginToken;
 
   /**
    * The last token in the token stream that was parsed to form this compilation unit. This token
    * should always have a type of [TokenType.EOF].
    */
-  Token endToken;
+  final Token endToken;
 
   /**
    * The tag nodes contained in the receiver (not `null`, contains no `null`s).
    */
   List<XmlTagNode> _tagNodes;
 
   /**
    * Construct a new instance representing the content of an HTML file.
    *
    * @param beginToken the first token in the file (not `null`)
    * @param tagNodes child tag nodes of the receiver (not `null`, contains no `null`s)
    * @param endToken the last token in the token stream which should be of type
    *          [TokenType.EOF]
    */
-  HtmlUnit(Token beginToken, List<XmlTagNode> tagNodes, Token endToken) {
-    this.beginToken = beginToken;
+  HtmlUnit(this.beginToken, List<XmlTagNode> tagNodes, this.endToken) {
     this._tagNodes = becomeParentOfAll(tagNodes);
-    this.endToken = endToken;
   }
 
   @override
   accept(XmlVisitor visitor) => visitor.visitHtmlUnit(this);
 
   /**
    * Return the element associated with this HTML unit.
    *
    * @return the element or `null` if the receiver is not resolved
    */
@@ skipping 16 matching lines @@
     super.element = element;
   }
 
   @override
   void visitChildren(XmlVisitor visitor) {
     for (XmlTagNode node in _tagNodes) {
       node.accept(visitor);
     }
   }
 }