New analyzer snapshot.

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

 // 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' show ASTVisitor, CompilationUnit, Expression;
 import 'element.dart' show HtmlElementImpl, HtmlScriptElement;
 import 'engine.dart' show AnalysisEngine;
 
 /**
  * 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.
  *
  * @coverage dart.engine.html
  */
 class Token {
   /**
    * The offset from the beginning of the file to the first character in the token.
    */
-  int offset = 0;
+  int _offset = 0;
 
   /**
    * The previous token in the token stream.
    */
   Token previous;
 
   /**
    * The next token in the token stream.
    */
-  Token next;
+  Token _next;
 
   /**
    * The type of the token.
    */
-  TokenType type;
+  TokenType _type;
 
   /**
    * The lexeme represented by this token.
    */
-  String lexeme;
+  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;
-    this.lexeme = StringUtilities.intern(value);
-    this.offset = offset;
+    this._type = type;
+    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
    * this token to be the previous token for the given token.
    *
    * @param token the next token in the token stream
    * @return the token that was passed in
    */
   Token setNext(Token token) {
-    next = token;
+    _next = token;
     token.previous = this;
     return token;
   }
 
   String toString() => lexeme;
 }
 
 /**
  * Instances of the class `EmbeddedExpression` represent an expression enclosed between
  * <code>{{</code> and <code>}}</code> delimiters.
  */
 class EmbeddedExpression {
   /**
    * The offset of the first character of the opening delimiter.
    */
-  int openingOffset = 0;
+  final int openingOffset;
 
   /**
    * The expression that is enclosed between the delimiters.
    */
-  Expression expression;
+  final Expression expression;
 
   /**
    * The offset of the first character of the closing delimiter.
    */
-  int closingOffset = 0;
+  final int closingOffset;
 
   /**
    * An empty array of embedded expressions.
    */
   static List<EmbeddedExpression> EMPTY_ARRAY = new List<EmbeddedExpression>(0);
 
   /**
    * Initialize a newly created embedded expression to represent the given expression.
    *
    * @param openingOffset the offset of the first character of the opening delimiter
    * @param expression the expression that is enclosed between the delimiters
    * @param closingOffset the offset of the first character of the closing delimiter
    */
-  EmbeddedExpression(int openingOffset, Expression expression, int closingOffset) {
-    this.openingOffset = openingOffset;
-    this.expression = expression;
-    this.closingOffset = closingOffset;
-  }
+  EmbeddedExpression(this.openingOffset, this.expression, this.closingOffset);
 }
 
 /**
  * Instances of `HtmlParseResult` hold the result of parsing an HTML file.
  *
  * @coverage dart.engine.html
  */
 class HtmlParseResult extends HtmlScanResult {
   /**
    * The unit containing the parsed information (not `null`).
    */
-  HtmlUnit htmlUnit;
+  HtmlUnit _unit;
 
   HtmlParseResult(int modificationTime, Token token, List<int> lineStarts, HtmlUnit unit) : super(modificationTime, token, lineStarts) {
-    this.htmlUnit = unit;
+    this._unit = unit;
   }
+
+  /**
+   * Answer the unit generated by parsing the source
+   *
+   * @return the unit (not `null`)
+   */
+  HtmlUnit get htmlUnit => _unit;
 }
 
 /**
  * Instances of the class `TagWithEmbeddedExpressions` represent a tag whose text content
  * contains one or more embedded expressions.
  */
 class TagWithEmbeddedExpressions extends XmlTagNode {
   /**
    * The expressions that are embedded in the tag's content.
    */
-  List<EmbeddedExpression> _expressions;
+  final List<EmbeddedExpression> expressions;
 
   /**
    * Initialize a newly created tag whose text content contains one or more embedded expressions.
    *
    * @param nodeStart the token marking the beginning of the tag
    * @param tag the name of the tag
    * @param attributes the attributes in the tag
    * @param attributeEnd the token terminating the region where attributes can be
    * @param tagNodes the children of the tag
    * @param contentEnd the token that starts the closing tag
    * @param closingTag the name of the tag that occurs in the closing tag
    * @param nodeEnd the last token in the tag
    * @param expressions the expressions that are embedded in the value
    */
-  TagWithEmbeddedExpressions(Token nodeStart, Token tag, List<XmlAttributeNode> attributes, Token attributeEnd, List<XmlTagNode> tagNodes, Token contentEnd, Token closingTag, Token nodeEnd, List<EmbeddedExpression> expressions) : super(nodeStart, tag, attributes, attributeEnd, tagNodes, contentEnd, closingTag, nodeEnd) {
-    this._expressions = expressions;
-  }
-
-  List<EmbeddedExpression> get expressions => _expressions;
+  TagWithEmbeddedExpressions(Token nodeStart, Token tag, List<XmlAttributeNode> attributes, Token attributeEnd, List<XmlTagNode> tagNodes, Token contentEnd, Token closingTag, Token nodeEnd, this.expressions) : super(nodeStart, tag, attributes, attributeEnd, tagNodes, contentEnd, closingTag, nodeEnd);
 }
 
 /**
  * Instances of the class `RecursiveXmlVisitor` implement an XML visitor that will recursively
  * visit all of the nodes in an XML structure. For example, using an instance of this class to visit
  * a [XmlTagNode] will also cause all of the contained [XmlAttributeNode]s and
  * [XmlTagNode]s to be visited.
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or must
  * explicitly ask the visited node to visit its children. Failure to do so will cause the children
@@ skipping 254 matching lines @@
 }
 
 /**
  * Instances of the class `AttributeWithEmbeddedExpressions` represent an attribute whose
  * value contains one or more embedded expressions.
  */
 class AttributeWithEmbeddedExpressions extends XmlAttributeNode {
   /**
    * The expressions that are embedded in the attribute's value.
    */
-  List<EmbeddedExpression> _expressions;
+  final List<EmbeddedExpression> expressions;
 
   /**
    * Initialize a newly created attribute whose value contains one or more embedded expressions.
    *
    * @param name the name of the attribute
    * @param equals the equals sign separating the name from the value
    * @param value the value of the attribute
    * @param expressions the expressions that are embedded in the value
    */
-  AttributeWithEmbeddedExpressions(Token name, Token equals, Token value, List<EmbeddedExpression> expressions) : super(name, equals, value) {
-    this._expressions = expressions;
-  }
-
-  List<EmbeddedExpression> get expressions => _expressions;
+  AttributeWithEmbeddedExpressions(Token name, Token equals, Token value, this.expressions) : super(name, equals, value);
 }
 
 /**
  * Instances of the class `SimpleXmlVisitor` implement an AST visitor that will do nothing
  * when visiting an AST node. It is intended to be a superclass for classes that use the visitor
  * pattern primarily as a dispatch mechanism (and hence don't need to recursively visit a whole
  * structure) and that only need to visit a small number of node types.
  */
 class SimpleXmlVisitor<R> implements XmlVisitor<R> {
   R visitHtmlScriptTagNode(HtmlScriptTagNode node) => null;
@@ skipping 10 matching lines @@
  * required to implement the interface used to access the characters being scanned.
  *
  * @coverage dart.engine.html
  */
 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 257 matching lines @@
 
 /**
  * Instances of `HtmlScanResult` hold the result of scanning an HTML file.
  *
  * @coverage dart.engine.html
  */
 class HtmlScanResult {
   /**
    * The time at which the contents of the source were last set.
    */
-  int modificationTime = 0;
+  final int modificationTime;
 
   /**
    * The first token in the token stream (not `null`).
    */
-  Token token;
+  final Token token;
 
   /**
    * The line start information that was produced.
    */
-  List<int> lineStarts;
+  final List<int> lineStarts;
 
-  HtmlScanResult(int modificationTime, Token token, List<int> lineStarts) {
-    this.modificationTime = modificationTime;
-    this.token = token;
-    this.lineStarts = lineStarts;
-  }
+  HtmlScanResult(this.modificationTime, this.token, this.lineStarts);
 }
 
 /**
  * Instances of the class `StringScanner` implement a scanner that reads from a string. The
  * scanning logic is in the superclass.
  *
  * @coverage dart.engine.html
  */
 class StringScanner extends AbstractScanner {
   /**
@@ skipping 226 matching lines @@
       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;
-  }
+  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);
 
   String toString() => "-eof-";
 }
 
 /**
  * Instances of `XmlAttributeNode` represent name/value pairs owned by an [XmlTagNode].
  *
  * @coverage dart.engine.html
  */
 class XmlAttributeNode extends XmlNode {
-  Token name;
+  final Token name;
 
-  Token equals;
+  final Token equals;
 
-  Token value;
+  final Token value;
 
   /**
    * 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);
 
   accept(XmlVisitor visitor) => visitor.visitXmlAttributeNode(this);
 
   Token get beginToken => name;
 
   Token get endToken => value;
 
   /**
    * Return the expressions that are embedded in the attribute's value.
    *
@@ skipping 170 matching lines @@
 /**
  * Instances of the class `XmlParser` are used to parse tokens into a AST structure comprised
  * of [XmlNode]s.
  *
  * @coverage dart.engine.html
  */
 class XmlParser {
   /**
    * The source being parsed.
    */
-  Source source;
+  final Source source;
 
   /**
    * The next token to be parsed.
    */
-  Token currentToken;
+  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 22 matching lines @@
    */
   bool isSelfClosing(Token tag) => false;
 
   /**
    * 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;
+    _currentToken = firstToken;
     List<XmlTagNode> tagNodes = new List<XmlTagNode>();
     while (true) {
       while (true) {
-        if (currentToken.type == TokenType.LT) {
+        if (_currentToken.type == TokenType.LT) {
           tagNodes.add(parseTagNode());
-        } else if (currentToken.type == TokenType.DECLARATION || currentToken.type == TokenType.DIRECTIVE || currentToken.type == TokenType.COMMENT) {
-          currentToken = currentToken.next;
-        } else if (currentToken.type == TokenType.EOF) {
+        } else if (_currentToken.type == TokenType.DECLARATION || _currentToken.type == TokenType.DIRECTIVE || _currentToken.type == TokenType.COMMENT) {
+          _currentToken = _currentToken.next;
+        } else if (_currentToken.type == TokenType.EOF) {
           return tagNodes;
         } else {
           reportUnexpectedToken();
-          currentToken = currentToken.next;
+          _currentToken = _currentToken.next;
         }
         break;
       }
     }
   }
 
   /**
+   * Answer the current token.
+   *
+   * @return the current token
+   */
+  Token get currentToken => _currentToken;
+
+  /**
    * Insert a synthetic token of the specified type before the current token
    *
    * @param type the type of token to be inserted (not `null`)
    * @return the synthetic token that was inserted (not `null`)
    */
   Token insertSyntheticToken(TokenType type) {
-    Token token = new Token.con2(type, currentToken.offset, "");
-    currentToken.previous.setNext(token);
-    token.setNext(currentToken);
+    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].
    *
    * @return the attribute (not `null`)
    */
   XmlAttributeNode parseAttribute() {
-    Token name = currentToken;
-    currentToken = currentToken.next;
+    Token name = _currentToken;
+    _currentToken = _currentToken.next;
     Token equals;
-    if (identical(currentToken.type, TokenType.EQ)) {
-      equals = currentToken;
-      currentToken = currentToken.next;
+    if (identical(_currentToken.type, TokenType.EQ)) {
+      equals = _currentToken;
+      _currentToken = _currentToken.next;
     } else {
       reportUnexpectedToken();
       equals = insertSyntheticToken(TokenType.EQ);
     }
     Token value;
-    if (identical(currentToken.type, TokenType.STRING)) {
-      value = currentToken;
-      currentToken = currentToken.next;
+    if (identical(_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;
+    TokenType type = _currentToken.type;
     if (identical(type, TokenType.GT) || identical(type, TokenType.SLASH_GT) || identical(type, TokenType.EOF)) {
       return XmlTagNode.NO_ATTRIBUTES;
     }
     List<XmlAttributeNode> attributes = new List<XmlAttributeNode>();
     while (true) {
       while (true) {
-        if (currentToken.type == TokenType.GT || currentToken.type == TokenType.SLASH_GT || currentToken.type == TokenType.EOF) {
+        if (_currentToken.type == TokenType.GT || _currentToken.type == TokenType.SLASH_GT || _currentToken.type == TokenType.EOF) {
           return attributes;
-        } else if (currentToken.type == TokenType.TAG) {
+        } else if (_currentToken.type == TokenType.TAG) {
           attributes.add(parseAttribute());
         } else {
           reportUnexpectedToken();
-          currentToken = currentToken.next;
+          _currentToken = _currentToken.next;
         }
         break;
       }
     }
   }
 
   /**
    * 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;
+    TokenType type = _currentToken.type;
     if (identical(type, TokenType.LT_SLASH) || identical(type, TokenType.EOF)) {
       return XmlTagNode.NO_TAG_NODES;
     }
     List<XmlTagNode> nodes = new List<XmlTagNode>();
     while (true) {
       while (true) {
-        if (currentToken.type == TokenType.LT) {
+        if (_currentToken.type == TokenType.LT) {
           nodes.add(parseTagNode());
-        } else if (currentToken.type == TokenType.LT_SLASH || currentToken.type == TokenType.EOF) {
+        } else if (_currentToken.type == TokenType.LT_SLASH || _currentToken.type == TokenType.EOF) {
           return nodes;
-        } else if (currentToken.type == TokenType.COMMENT) {
-          currentToken = currentToken.next;
+        } else if (_currentToken.type == TokenType.COMMENT) {
+          _currentToken = _currentToken.next;
         } else {
           reportUnexpectedToken();
-          currentToken = currentToken.next;
+          _currentToken = _currentToken.next;
         }
         break;
       }
     }
   }
 
   /**
    * 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() {
-    Token nodeStart = currentToken;
-    currentToken = currentToken.next;
+    Token nodeStart = _currentToken;
+    _currentToken = _currentToken.next;
     Token tag;
-    if (identical(currentToken.type, TokenType.TAG)) {
-      tag = currentToken;
-      currentToken = currentToken.next;
+    if (identical(_currentToken.type, TokenType.TAG)) {
+      tag = _currentToken;
+      _currentToken = _currentToken.next;
     } else {
       reportUnexpectedToken();
       tag = insertSyntheticToken(TokenType.TAG);
     }
     List<XmlAttributeNode> attributes = parseAttributes();
     Token attributeEnd;
-    if (identical(currentToken.type, TokenType.GT) || identical(currentToken.type, TokenType.SLASH_GT)) {
-      attributeEnd = currentToken;
-      currentToken = currentToken.next;
+    if (identical(_currentToken.type, TokenType.GT) || identical(_currentToken.type, TokenType.SLASH_GT)) {
+      attributeEnd = _currentToken;
+      _currentToken = _currentToken.next;
     } else {
       reportUnexpectedToken();
       attributeEnd = insertSyntheticToken(TokenType.SLASH_GT);
     }
     if (identical(attributeEnd.type, TokenType.SLASH_GT) || isSelfClosing(tag)) {
-      return createTagNode(nodeStart, tag, attributes, attributeEnd, XmlTagNode.NO_TAG_NODES, currentToken, null, attributeEnd);
+      return createTagNode(nodeStart, tag, attributes, attributeEnd, XmlTagNode.NO_TAG_NODES, _currentToken, null, attributeEnd);
     }
     List<XmlTagNode> tagNodes = parseChildTagNodes();
     Token contentEnd;
-    if (identical(currentToken.type, TokenType.LT_SLASH)) {
-      contentEnd = currentToken;
-      currentToken = currentToken.next;
+    if (identical(_currentToken.type, TokenType.LT_SLASH)) {
+      contentEnd = _currentToken;
+      _currentToken = _currentToken.next;
     } else {
       reportUnexpectedToken();
       contentEnd = insertSyntheticToken(TokenType.LT_SLASH);
     }
     Token closingTag;
-    if (identical(currentToken.type, TokenType.TAG)) {
-      closingTag = currentToken;
-      currentToken = currentToken.next;
+    if (identical(_currentToken.type, TokenType.TAG)) {
+      closingTag = _currentToken;
+      _currentToken = _currentToken.next;
     } else {
       reportUnexpectedToken();
       closingTag = insertSyntheticToken(TokenType.TAG);
     }
     Token nodeEnd;
-    if (identical(currentToken.type, TokenType.GT)) {
-      nodeEnd = currentToken;
-      currentToken = currentToken.next;
+    if (identical(_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);
   }
 
   /**
    * Report the current token as unexpected
    */
@@ 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;
+  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;
+  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;
 
   /**
    * 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 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
    *          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
    *          `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;
-    this.attributes = becomeParentOfEmpty(attributes, NO_ATTRIBUTES);
-    this.attributeEnd = attributeEnd;
-    this.tagNodes = becomeParentOfEmpty(tagNodes, NO_TAG_NODES);
-    this.contentEnd = contentEnd;
-    this.closingTag = closingTag;
-    this.nodeEnd = nodeEnd;
+  XmlTagNode(this.nodeStart, this.tag, List<XmlAttributeNode> attributes, this.attributeEnd, List<XmlTagNode> tagNodes, this.contentEnd, this.closingTag, this.nodeEnd) {
+    this._attributes = becomeParentOfEmpty(attributes, NO_ATTRIBUTES);
+    this._tagNodes = becomeParentOfEmpty(tagNodes, NO_TAG_NODES);
   }
 
   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
    */
   XmlAttributeNode getAttribute(String name) {
-    for (XmlAttributeNode attribute in attributes) {
+    for (XmlAttributeNode attribute in _attributes) {
       if (attribute.name.lexeme == name) {
         return attribute;
       }
     }
     return null;
   }
 
   /**
+   * 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]).
    *
    * @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;
@@ skipping 29 matching lines @@
   Token get endToken {
     if (nodeEnd != null) {
       return nodeEnd;
     }
     if (closingTag != null) {
       return closingTag;
     }
     if (contentEnd != null) {
       return contentEnd;
     }
-    if (!tagNodes.isEmpty) {
-      return tagNodes[tagNodes.length - 1].endToken;
+    if (!_tagNodes.isEmpty) {
+      return _tagNodes[_tagNodes.length - 1].endToken;
     }
     if (attributeEnd != null) {
       return attributeEnd;
     }
-    if (!attributes.isEmpty) {
-      return attributes[attributes.length - 1].endToken;
+    if (!_attributes.isEmpty) {
+      return _attributes[_attributes.length - 1].endToken;
     }
     return tag;
   }
 
   /**
    * Return the expressions that are embedded in the tag's content.
    *
    * @return the expressions that are embedded in the tag's content
    */
   List<EmbeddedExpression> get expressions => EmbeddedExpression.EMPTY_ARRAY;
 
+  /**
+   * 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;
+
   void visitChildren(XmlVisitor visitor) {
-    for (XmlAttributeNode node in attributes) {
+    for (XmlAttributeNode node in _attributes) {
       node.accept(visitor);
     }
-    for (XmlTagNode node in tagNodes) {
+    for (XmlTagNode node in _tagNodes) {
       node.accept(visitor);
     }
   }
 
   /**
    * Same as [becomeParentOf], but returns given "ifEmpty" if "children" is empty
    */
   List becomeParentOfEmpty(List children, List ifEmpty) {
     if (children != null && children.isEmpty) {
       return ifEmpty;
@@ skipping 202 matching lines @@
 
 /**
  * Instances of the class `HtmlUnit` represent the contents of an HTML file.
  *
  * @coverage dart.engine.html
  */
 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;
+  List<XmlTagNode> _tagNodes;
 
   /**
    * The element associated with this HTML unit or `null` if the receiver is not resolved.
    */
   HtmlElementImpl element;
 
   /**
    * 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;
-    this.tagNodes = becomeParentOf(tagNodes);
-    this._endToken = endToken;
+  HtmlUnit(this.beginToken, List<XmlTagNode> tagNodes, this.endToken) {
+    this._tagNodes = becomeParentOf(tagNodes);
   }
 
   accept(XmlVisitor visitor) => visitor.visitHtmlUnit(this);
 
-  Token get beginToken => _beginToken;
-
-  Token get endToken => _endToken;
+  /**
+   * 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;
 
   void visitChildren(XmlVisitor visitor) {
-    for (XmlTagNode node in tagNodes) {
+    for (XmlTagNode node in _tagNodes) {
       node.accept(visitor);
     }
   }
 }