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 'element.dart' show HtmlElementImpl;
 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;
 
   /**
    * The previous token in the token stream.
    */
   Token previous;
 
@@ skipping 63 matching lines @@
    * 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;
     token.previous = this;
     return token;
   }
+
   String toString() => lexeme;
 }
+
 /**
  * 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;
+
   HtmlParseResult(int modificationTime, Token token, List<int> lineStarts, HtmlUnit unit) : super(modificationTime, token, lineStarts) {
     this.htmlUnit = unit;
   }
 }
+
 /**
  * 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
  * of the visited node to not be visited.
  *
  * @coverage dart.engine.html
  */
 class RecursiveXmlVisitor<R> implements XmlVisitor<R> {
   R visitHtmlUnit(HtmlUnit node) {
     node.visitChildren(this);
     return null;
   }
+
   R visitXmlAttributeNode(XmlAttributeNode node) {
     node.visitChildren(this);
     return null;
   }
+
   R visitXmlTagNode(XmlTagNode node) {
     node.visitChildren(this);
     return null;
   }
 }
+
 /**
  * The abstract class `XmlNode` defines behavior common to all XML/HTML nodes.
  *
  * @coverage dart.engine.html
  */
 abstract class XmlNode {
-
   /**
    * The parent of the node, or `null` if the node is the root of an AST structure.
    */
   XmlNode _parent;
 
   /**
    * Use the given visitor to visit this node.
    *
    * @param visitor the visitor that will visit this node
    * @return the value returned by the visitor as a result of visiting this node
@@ skipping 54 matching lines @@
 
   /**
    * Return this node's parent node, or `null` if this node is the root of an AST structure.
    *
    * Note that the relationship between an AST node and its parent node may change over the lifetime
    * of a node.
    *
    * @return the parent of this node, or `null` if none
    */
   XmlNode get parent => _parent;
+
   String toString() {
     PrintStringWriter writer = new PrintStringWriter();
     accept(new ToSourceVisitor(writer));
     return writer.toString();
   }
 
   /**
    * Use the given visitor to visit all of the children of this node. The children will be visited
    * in source order.
    *
@@ skipping 30 matching lines @@
       node.parent = this;
     }
     return child;
   }
 
   /**
    * This method exists for debugging purposes only.
    */
   void appendIdentifier(JavaStringBuilder builder, XmlNode node) {
     if (node is XmlTagNode) {
-      builder.append(((node as XmlTagNode)).tag.lexeme);
+      builder.append((node as XmlTagNode).tag.lexeme);
     } else if (node is XmlAttributeNode) {
-      builder.append(((node as XmlAttributeNode)).name.lexeme);
+      builder.append((node as XmlAttributeNode).name.lexeme);
     } else {
       builder.append("htmlUnit");
     }
   }
 
   /**
    * This method exists for debugging purposes only.
    */
   String buildRecursiveStructureMessage(XmlNode newParent) {
     JavaStringBuilder builder = new JavaStringBuilder();
@@ skipping 25 matching lines @@
     while (current != null) {
       if (identical(current, this)) {
         AnalysisEngine.instance.logger.logError3(new IllegalArgumentException(buildRecursiveStructureMessage(newParent)));
         return;
       }
       current = current.parent;
     }
     _parent = newParent;
   }
 }
+
 /**
  * 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 visitHtmlUnit(HtmlUnit htmlUnit) => null;
+
   R visitXmlAttributeNode(XmlAttributeNode xmlAttributeNode) => null;
+
   R visitXmlTagNode(XmlTagNode xmlTagNode) => null;
 }
+
 /**
  * The abstract class `AbstractScanner` implements a scanner for HTML code. Subclasses are
  * 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> [];
 
   /**
@@ skipping 93 matching lines @@
    * @return the character at the current position
    */
   int peek();
 
   /**
    * Record the fact that we are at the beginning of a new line in the source.
    */
   void recordStartOfLine() {
     _lineStarts.add(offset);
   }
+
   void appendEofToken() {
     Token eofToken = new Token.con1(TokenType.EOF, offset);
     eofToken.setNext(eofToken);
     _tail = _tail.setNext(eofToken);
   }
+
   Token emit(Token token) {
     _tail.setNext(token);
     _tail = token;
     return token;
   }
+
   Token emit2(TokenType type, int start) => emit(new Token.con1(type, start));
+
   Token emit3(TokenType type, int start, int count) => emit(new Token.con2(type, start, getString(start, count)));
+
   Token firstToken() => _tokens.next;
+
   int recordStartOfLineAndAdvance(int c) {
     if (c == 0xD) {
       c = advance();
       if (c == 0xA) {
         c = advance();
       }
       recordStartOfLine();
     } else if (c == 0xA) {
       c = advance();
       recordStartOfLine();
     } else {
       c = advance();
     }
     return c;
   }
+
   void scan() {
     bool inBrackets = false;
     String endPassThrough = null;
     int c = advance();
     while (c >= 0) {
       int start = offset;
       if (c == 0x3C) {
         c = advance();
         if (c == 0x21) {
           c = advance();
@@ skipping 140 matching lines @@
           c = advance();
         }
         emit3(TokenType.TAG, start, -1);
       } else {
         emit3(TokenType.TEXT, start, 0);
         c = advance();
       }
     }
   }
 }
+
 /**
  * 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;
 
   /**
    * The first token in the token stream (not `null`).
    */
   Token token;
 
   /**
    * The line start information that was produced.
    */
   List<int> lineStarts;
+
   HtmlScanResult(int modificationTime, Token token, List<int> lineStarts) {
     this.modificationTime = modificationTime;
     this.token = token;
     this.lineStarts = 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 {
-
   /**
    * The string from which characters will be read.
    */
   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;
     this._charOffset = -1;
   }
+
   int get offset => _charOffset;
+
   void set offset(int offset) {
     _charOffset = offset;
   }
+
   int advance() {
     if (++_charOffset < _stringLength) {
       return _string.codeUnitAt(_charOffset);
     }
     _charOffset = _stringLength;
     return -1;
   }
+
   String getString(int start, int endDelta) => _string.substring(start, _charOffset + 1 + endDelta);
+
   int peek() {
     if (_charOffset + 1 < _stringLength) {
       return _string.codeUnitAt(_charOffset + 1);
     }
     return -1;
   }
 }
+
 /**
  * Instances of the class `CharBufferScanner` implement a scanner that reads from a character
  * buffer. The scanning logic is in the superclass.
  *
  * @coverage dart.engine.html
  */
 class CharBufferScanner extends AbstractScanner {
-
   /**
    * The buffer from which characters will be read.
    */
   CharSequence _buffer;
 
   /**
    * The number of characters in the buffer.
    */
   int _bufferLength = 0;
 
   /**
    * The index of the last character that was read.
    */
   int _charOffset = 0;
 
   /**
    * Initialize a newly created scanner to scan the characters in the given character buffer.
    *
    * @param source the source being scanned
    * @param buffer the buffer from which characters will be read
    */
   CharBufferScanner(Source source, CharSequence buffer) : super(source) {
     this._buffer = buffer;
     this._bufferLength = buffer.length();
     this._charOffset = -1;
   }
+
   int get offset => _charOffset;
+
   int advance() {
     if (++_charOffset < _bufferLength) {
       return _buffer.charAt(_charOffset);
     }
     _charOffset = _bufferLength;
     return -1;
   }
+
   String getString(int start, int endDelta) => _buffer.subSequence(start, _charOffset + 1 + endDelta).toString();
+
   int peek() {
     if (_charOffset + 1 < _bufferLength) {
       return _buffer.charAt(_charOffset + 1);
     }
     return -1;
   }
 }
+
 /**
  * Instances of the class `ToSourceVisitor` write a source representation of a visited XML
  * node (and all of it's children) to a writer.
  *
  * @coverage dart.engine.html
  */
 class ToSourceVisitor implements XmlVisitor<Object> {
-
   /**
    * The writer to which the source is to be written.
    */
   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;
   }
+
   Object visitHtmlUnit(HtmlUnit node) {
     for (XmlTagNode child in node.tagNodes) {
       visit(child);
     }
     return null;
   }
+
   Object visitXmlAttributeNode(XmlAttributeNode node) {
     String name = node.name.lexeme;
     Token value = node.value;
     if (name.length == 0) {
       _writer.print("__");
     } else {
       _writer.print(name);
     }
     _writer.print("=");
     if (value == null) {
       _writer.print("__");
     } else {
       _writer.print(value.lexeme);
     }
     return null;
   }
+
   Object visitXmlTagNode(XmlTagNode node) {
     _writer.print("<");
     String tagName = node.tag.lexeme;
     _writer.print(tagName);
     for (XmlAttributeNode attribute in node.attributes) {
       _writer.print(" ");
       visit(attribute);
     }
     _writer.print(node.attributeEnd.lexeme);
     if (node.closingTag != null) {
@@ skipping 11 matching lines @@
    * Safely visit the given node.
    *
    * @param node the node to be visited
    */
   void visit(XmlNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 }
+
 /**
  * The enumeration `TokenType` defines the types of tokens that can be returned by the
  * scanner.
  *
  * @coverage dart.engine.html
  */
 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 final TokenType EQ = new TokenType('EQ', 1, "=");
+
   static final TokenType GT = new TokenType('GT', 2, ">");
+
   static final TokenType LT_SLASH = new TokenType('LT_SLASH', 3, "</");
+
   static final TokenType LT = new TokenType('LT', 4, "<");
+
   static final TokenType SLASH_GT = new TokenType('SLASH_GT', 5, "/>");
+
   static final TokenType COMMENT = new TokenType('COMMENT', 6, null);
+
   static final TokenType DECLARATION = new TokenType('DECLARATION', 7, null);
+
   static final TokenType DIRECTIVE = new TokenType('DIRECTIVE', 8, null);
+
   static final TokenType STRING = new TokenType('STRING', 9, null);
+
   static final TokenType TAG = new TokenType('TAG', 10, null);
+
   static final TokenType TEXT = new TokenType('TEXT', 11, null);
+
   static final List<TokenType> values = [
       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;
+
   TokenType(String name, int ordinal, String lexeme) : super(name, ordinal) {
     this.lexeme = lexeme;
   }
 }
+
 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;
+
   Token equals;
+
   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;
   }
+
   accept(XmlVisitor visitor) => visitor.visitXmlAttributeNode(this);
+
   Token get beginToken => name;
+
   Token get endToken => value;
 
   /**
    * Answer the lexeme for the value token without the leading and trailing quotes.
    *
    * @return the text or `null` if the value is not specified
    */
   String get text {
     if (value == null) {
       return null;
@@ skipping 10 matching lines @@
       } else if (text.codeUnitAt(0) == 0x27) {
         if (len > 1 && text.codeUnitAt(len - 1) == 0x27) {
           return text.substring(1, len - 1);
         } else {
           return text.substring(1);
         }
       }
     }
     return text;
   }
+
   void visitChildren(XmlVisitor visitor) {
   }
 }
+
 /**
  * The interface `XmlVisitor` defines the behavior of objects that can be used to visit an
  * [XmlNode] structure.
  *
  * @coverage dart.engine.html
  */
 abstract class XmlVisitor<R> {
   R visitHtmlUnit(HtmlUnit htmlUnit);
+
   R visitXmlAttributeNode(XmlAttributeNode xmlAttributeNode);
+
   R visitXmlTagNode(XmlTagNode xmlTagNode);
 }
+
 /**
  * Instances of `HtmlScanner` receive and scan HTML content from a [Source].<br/>
  * For example, the following code scans HTML source and returns the result:
  *
  * <pre>
  *   HtmlScanner scanner = new HtmlScanner(source);
  *   source.getContents(scanner);
  *   return scanner.getResult();
  * </pre>
  *
@@ skipping 23 matching lines @@
   Token _token;
 
   /**
    * Construct a new instance to scan the specified source.
    *
    * @param source the source to be scanned (not `null`)
    */
   HtmlScanner(Source source) {
     this._source = source;
   }
+
   void accept(CharBuffer contents, int modificationTime) {
     this._modificationTime = modificationTime;
     _scanner = new CharBufferScanner(_source, contents);
     _scanner.passThroughElements = _SCRIPT_TAG;
     _token = _scanner.tokenize();
   }
+
   void accept2(String contents, int modificationTime) {
     this._modificationTime = modificationTime;
     _scanner = new StringScanner(_source, contents);
     _scanner.passThroughElements = _SCRIPT_TAG;
     _token = _scanner.tokenize();
   }
 
   /**
    * Answer the result of scanning the source
    *
    * @return the result (not `null`)
    */
   HtmlScanResult get result => new HtmlScanResult(_modificationTime, _token, _scanner.lineStarts);
 }
+
 /**
  * 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;
 
   /**
    * The next token to be parsed.
    */
   Token currentToken;
 
@@ skipping 194 matching lines @@
     }
     return new XmlTagNode(nodeStart, tag, attributes, attributeEnd, tagNodes, contentEnd, closingTag, nodeEnd);
   }
 
   /**
    * Report the current token as unexpected
    */
   void reportUnexpectedToken() {
   }
 }
+
 /**
  * Instances of `XmlTagNode` represent XML or HTML elements such as `` and
  * `<body foo="bar"> ... </body>`.
  *
  * @coverage dart.engine.html
  */
 class XmlTagNode extends XmlNode {
-
   /**
    * 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>());
 
@@ skipping 77 matching lines @@
   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;
   }
+
   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) {
       if (attribute.name.lexeme == name) {
         return attribute;
       }
     }
     return null;
   }
 
   /**
    * 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;
   }
+
   Token get beginToken => nodeStart;
 
   /**
    * Answer a string representing the content contained in the receiver. This includes the textual
    * representation of any child tag nodes ([getTagNodes]). Whitespace between '&lt;',
    * '&lt;/', and '>', '/>' is discarded, but all other whitespace is preserved.
    *
    * @return the content (not `null`)
    */
   String get content {
     Token token = attributeEnd.next;
     if (identical(token, contentEnd)) {
       return "";
     }
     String content = token.lexeme;
     token = token.next;
     if (identical(token, contentEnd)) {
       return content;
     }
     JavaStringBuilder buffer = new JavaStringBuilder();
     while (token != contentEnd) {
       buffer.append(token.lexeme);
       token = token.next;
     }
     return buffer.toString();
   }
+
   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 (attributeEnd != null) {
       return attributeEnd;
     }
     if (!attributes.isEmpty) {
       return attributes[attributes.length - 1].endToken;
     }
     return tag;
   }
+
   void visitChildren(XmlVisitor visitor) {
     for (XmlAttributeNode node in attributes) {
       node.accept(visitor);
     }
     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;
     }
     return becomeParentOf(children);
   }
 }
+
 /**
  * Instances of the class `HtmlParser` are used to parse tokens into a AST structure comprised
  * of [XmlNode]s.
  *
  * @coverage dart.engine.html
  */
 class HtmlParser extends XmlParser {
   static Set<String> SELF_CLOSING = new Set<String>();
 
   /**
@@ skipping 20 matching lines @@
    * Scan then parse the specified source.
    *
    * @param source the source to be scanned and parsed (not `null`)
    * @return the parse result (not `null`)
    */
   HtmlParseResult parse2(Source source) {
     HtmlScanner scanner = new HtmlScanner(source);
     source.getContents(scanner);
     return parse(scanner.result);
   }
+
   bool isSelfClosing(Token tag) => SELF_CLOSING.contains(tag.lexeme);
 }
+
 /**
  * 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;
 
   /**
    * 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;
@@ skipping 14 matching lines @@
    * @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;
   }
+
   accept(XmlVisitor visitor) => visitor.visitHtmlUnit(this);
+
   Token get beginToken => _beginToken;
+
   Token get endToken => _endToken;
+
   void visitChildren(XmlVisitor visitor) {
     for (XmlTagNode node in tagNodes) {
       node.accept(visitor);
     }
   }
 }