Translate Java's @Override into Dart's @override.

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 117 matching lines @@
    *
    * @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;
   }
 
+  @override
   String toString() => lexeme;
 }
 
 /**
  * Implementation of [XmlExpression] for an [Expression] embedded without any wrapping
  * characters.
  */
 class RawXmlExpression extends XmlExpression {
   final Expression expression;
 
   RawXmlExpression(this.expression);
 
+  @override
   int get end => expression.end;
 
+  @override
   int get length => expression.length;
 
+  @override
   int get offset => expression.offset;
 
+  @override
   XmlExpression_Reference getReference(int offset) {
     AstNode node = new NodeLocator.con1(offset).searchWithin(expression);
     if (node != null) {
       Element element = ElementLocator.locate(node);
       return new XmlExpression_Reference(element, node.offset, node.length);
     }
     return null;
   }
 }
 
 /**
  * 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.
  */
 class RecursiveXmlVisitor<R> implements XmlVisitor<R> {
+  @override
   R visitHtmlScriptTagNode(HtmlScriptTagNode node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitHtmlUnit(HtmlUnit node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitXmlAttributeNode(XmlAttributeNode node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitXmlTagNode(XmlTagNode node) {
     node.visitChildren(this);
     return null;
   }
 }
 
 /**
  * Utilities locating [Expression]s and [Element]s in [HtmlUnit].
  */
 class HtmlUnitUtils {
@@ skipping 106 matching lines @@
 class HtmlUnitUtils_FoundTagNodeError extends Error {
 }
 
 class RecursiveXmlVisitor_HtmlUnitUtils_getAttributeNode extends RecursiveXmlVisitor<Object> {
   int offset = 0;
 
   List<XmlAttributeNode> result;
 
   RecursiveXmlVisitor_HtmlUnitUtils_getAttributeNode(this.offset, this.result) : super();
 
+  @override
   Object visitXmlAttributeNode(XmlAttributeNode node) {
     Token nameToken = node.nameToken;
     if (nameToken.offset <= offset && offset < nameToken.end) {
       result[0] = node;
       throw new HtmlUnitUtils_FoundAttributeNodeError();
     }
     return super.visitXmlAttributeNode(node);
   }
 }
 
 class ExpressionVisitor_HtmlUnitUtils_getExpression extends ExpressionVisitor {
   int offset = 0;
 
   List<Expression> result;
 
   ExpressionVisitor_HtmlUnitUtils_getExpression(this.offset, this.result) : super();
 
+  @override
   void visitExpression(Expression expression) {
     Expression at = HtmlUnitUtils._getExpressionAt(expression, offset);
     if (at != null) {
       result[0] = at;
       throw new HtmlUnitUtils_FoundExpressionError();
     }
   }
 }
 
 class RecursiveXmlVisitor_HtmlUnitUtils_getTagNode extends RecursiveXmlVisitor<Object> {
   int offset = 0;
 
   List<XmlTagNode> result;
 
   RecursiveXmlVisitor_HtmlUnitUtils_getTagNode(this.offset, this.result) : super();
 
+  @override
   Object visitXmlTagNode(XmlTagNode node) {
     super.visitXmlTagNode(node);
     Token tagToken = node.tagToken;
     if (tagToken.offset <= offset && offset < tagToken.end) {
       result[0] = node;
       throw new HtmlUnitUtils_FoundTagNodeError();
     }
     return null;
   }
 }
@@ skipping 21 matching lines @@
    * @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
    */
   HtmlScriptTagNode(Token nodeStart, Token tag, List<XmlAttributeNode> attributes, Token attributeEnd, List<XmlTagNode> tagNodes, Token contentEnd, Token closingTag, Token nodeEnd) : super(nodeStart, tag, attributes, attributeEnd, tagNodes, contentEnd, closingTag, nodeEnd);
 
+  @override
   accept(XmlVisitor visitor) => visitor.visitHtmlScriptTagNode(this);
 
   /**
    * Return the AST structure representing the Dart code within this tag, or `null` if this
    * tag references an external script.
    *
    * @return the AST structure representing the Dart code within this tag
    */
   CompilationUnit get script => _script;
 
@@ skipping 100 matching lines @@
 
   /**
    * Set the element associated with this node.
    *
    * @param element the element
    */
   void set element(Element element) {
     this._element = element;
   }
 
+  @override
   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 93 matching lines @@
   }
 }
 
 /**
  * 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> {
+  @override
   R visitHtmlScriptTagNode(HtmlScriptTagNode node) => null;
 
+  @override
   R visitHtmlUnit(HtmlUnit htmlUnit) => null;
 
+  @override
   R visitXmlAttributeNode(XmlAttributeNode xmlAttributeNode) => null;
 
+  @override
   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.
  */
 abstract class AbstractScanner {
   static List<String> _NO_PASS_THROUGH_ELEMENTS = <String> [];
 
@@ skipping 334 matching lines @@
    *
    * @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;
   }
 
+  @override
   int get offset => _charOffset;
 
   void set offset(int offset) {
     _charOffset = offset;
   }
 
+  @override
   int advance() {
     if (++_charOffset < _stringLength) {
       return _string.codeUnitAt(_charOffset);
     }
     _charOffset = _stringLength;
     return -1;
   }
 
+  @override
   String getString(int start, int endDelta) => _string.substring(start, _charOffset + 1 + endDelta).toString();
 
+  @override
   int peek() {
     if (_charOffset + 1 < _stringLength) {
       return _string.codeUnitAt(_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.
  */
 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;
   }
 
+  @override
   Object visitHtmlScriptTagNode(HtmlScriptTagNode node) => visitXmlTagNode(node);
 
+  @override
   Object visitHtmlUnit(HtmlUnit node) {
     for (XmlTagNode child in node.tagNodes) {
       _visit(child);
     }
     return null;
   }
 
+  @override
   Object visitXmlAttributeNode(XmlAttributeNode node) {
     String name = node.name;
     Token value = node.valueToken;
     if (name.length == 0) {
       _writer.print("__");
     } else {
       _writer.print(name);
     }
     _writer.print("=");
     if (value == null) {
       _writer.print("__");
     } else {
       _writer.print(value.lexeme);
     }
     return null;
   }
 
+  @override
   Object visitXmlTagNode(XmlTagNode node) {
     _writer.print("<");
     String tagName = node.tag;
     _writer.print(tagName);
     for (XmlAttributeNode attribute in node.attributes) {
       _writer.print(" ");
       _visit(attribute);
     }
     _writer.print(node.attributeEnd.lexeme);
     if (node.closingTag != null) {
@@ skipping 70 matching lines @@
    * lexeme for this type of token.
    */
   final String 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);
 
+  @override
   String toString() => "-eof-";
 }
 
 /**
  * Instances of `XmlAttributeNode` represent name/value pairs owned by an [XmlTagNode].
  */
 class XmlAttributeNode extends XmlNode {
   Token _name;
 
   final Token equals;
 
   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, this.equals, Token value) {
     this._name = name;
     this._value = value;
   }
 
+  @override
   accept(XmlVisitor visitor) => visitor.visitXmlAttributeNode(this);
 
+  @override
   Token get beginToken => _name;
 
+  @override
   Token get endToken => _value;
 
   /**
    * Answer the attribute name. This may be a zero length string if the attribute is badly formed.
    *
    * @return the name (not `null`)
    */
   String get name => _name.lexeme;
 
   /**
@@ skipping 35 matching lines @@
   }
 
   /**
    * Answer the attribute value token. A properly formed value will start and end with matching
    * quote characters, but the value returned may not be properly formed.
    *
    * @return the value token or `null` if this represents a badly formed attribute
    */
   Token get valueToken => _value;
 
+  @override
   void visitChildren(XmlVisitor 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);
@@ skipping 414 matching lines @@
    *          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, Token tag, List<XmlAttributeNode> attributes, this.attributeEnd, List<XmlTagNode> tagNodes, this.contentEnd, this.closingTag, this.nodeEnd) {
     this._tag = tag;
     this._attributes = becomeParentOfAll(attributes, ifEmpty: NO_ATTRIBUTES);
     this._tagNodes = becomeParentOfAll(tagNodes, ifEmpty: NO_TAG_NODES);
   }
 
+  @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
    */
   XmlAttributeNode getAttribute(String name) {
     for (XmlAttributeNode attribute in _attributes) {
@@ skipping 18 matching lines @@
    * [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
   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 "";
     }
     //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) {
       buffer.append(token.lexeme);
       token = token.next;
     }
     return buffer.toString();
   }
 
+  @override
   Token get endToken {
     if (nodeEnd != null) {
       return nodeEnd;
     }
     if (closingTag != null) {
       return closingTag;
     }
     if (contentEnd != null) {
       return contentEnd;
     }
@@ skipping 24 matching lines @@
    */
   List<XmlTagNode> get tagNodes => _tagNodes;
 
   /**
    * 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);
     }
   }
 }
 
@@ skipping 70 matching lines @@
    * @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;
     List<XmlTagNode> tagNodes = parseTopTagNodes(token);
     return new HtmlUnit(token, tagNodes, currentToken);
   }
 
+  @override
   XmlAttributeNode createAttributeNode(Token name, Token equals, Token value) => new XmlAttributeNode(name, equals, value);
 
+  @override
   XmlTagNode createTagNode(Token nodeStart, Token tag, List<XmlAttributeNode> attributes, Token attributeEnd, List<XmlTagNode> tagNodes, Token contentEnd, Token closingTag, Token nodeEnd) {
     if (_isScriptNode(tag, attributes, tagNodes)) {
       HtmlScriptTagNode tagNode = new HtmlScriptTagNode(nodeStart, tag, attributes, attributeEnd, tagNodes, contentEnd, closingTag, nodeEnd);
       String contents = tagNode.content;
       int contentOffset = attributeEnd.end;
       LineInfo_Location location = _lineInfo.getLocation(contentOffset);
       sc.Scanner scanner = new sc.Scanner(source, new sc.SubSequenceReader(contents, contentOffset), _errorListener);
       scanner.setSourceStart(location.lineNumber, location.columnNumber);
       sc.Token firstToken = scanner.tokenize();
       Parser parser = new Parser(source, _errorListener);
       CompilationUnit unit = parser.parseCompilationUnit(firstToken);
       unit.lineInfo = _lineInfo;
       tagNode.script = unit;
       return tagNode;
     }
     return new XmlTagNode(nodeStart, tag, attributes, attributeEnd, tagNodes, contentEnd, closingTag, nodeEnd);
   }
 
+  @override
   bool isSelfClosing(Token tag) => SELF_CLOSING.contains(tag.lexeme);
 
   /**
    * Determine if the specified node is a Dart script.
    *
    * @param node the node to be tested (not `null`)
    * @return `true` if the node is a Dart script
    */
   bool _isScriptNode(Token tag, List<XmlAttributeNode> attributes, List<XmlTagNode> tagNodes) {
     if (tagNodes.length != 0 || tag.lexeme != _SCRIPT) {
@@ skipping 39 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(this.beginToken, List<XmlTagNode> tagNodes, this.endToken) {
     this._tagNodes = becomeParentOfAll(tagNodes);
   }
 
+  @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
    */
+  @override
   HtmlElement get element => super.element as HtmlElement;
 
   /**
    * 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;
 
+  @override
   void set element(Element element) {
     if (element != null && element is! HtmlElement) {
       throw new IllegalArgumentException("HtmlElement expected, but ${element.runtimeType} given");
     }
     super.element = element;
   }
 
+  @override
   void visitChildren(XmlVisitor visitor) {
     for (XmlTagNode node in _tagNodes) {
       node.accept(visitor);
     }
   }
 }