Reformat

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 65 matching lines @@
    * the source code has been scanned.
    *
    * @return the current offset of the scanner in the source
    */
   int get offset;
 
   /**
    * Set array of element tags for which the content between tags should be consider a single token.
    */
   void set passThroughElements(List<String> passThroughElements) {
-    this._passThroughElements =
-        passThroughElements != null ? passThroughElements : _NO_PASS_THROUGH_ELEMENTS;
+    this._passThroughElements = passThroughElements != null
+        ? passThroughElements
+        : _NO_PASS_THROUGH_ELEMENTS;
   }
 
   /**
    * Advance the current position and return the character at the new current position.
    *
    * @return the character at the new current position
    */
   int advance();
 
   /**
@@ skipping 256 matching lines @@
 
   static String _APPLICATION_DART_IN_SINGLE_QUOTES = "'application/dart'";
 
   static String _SCRIPT = "script";
 
   static String _TYPE = "type";
 
   /**
    * A set containing the names of tags that do not have a closing tag.
    */
-  static Set<String> SELF_CLOSING = new HashSet<String>.from(
-      <String>[
-          "area",
-          "base",
-          "basefont",
-          "br",
-          "col",
-          "frame",
-          "hr",
-          "img",
-          "input",
-          "link",
-          "meta",
-          "param",
-          "!"]);
+  static Set<String> SELF_CLOSING = new HashSet<String>.from(<String>[
+    "area",
+    "base",
+    "basefont",
+    "br",
+    "col",
+    "frame",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "!"
+  ]);
 
   /**
    * The line information associated with the source being parsed.
    */
   LineInfo _lineInfo;
 
   /**
    * The error listener to which errors will be reported.
    */
   final AnalysisErrorListener _errorListener;
 
   /**
    * 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, this._errorListener) : super(source);
 
   @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) {
+      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);
+      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);
+      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);
+    return new XmlTagNode(nodeStart, tag, attributes, attributeEnd, tagNodes,
+        contentEnd, closingTag, nodeEnd);
   }
 
   @override
   bool isSelfClosing(Token tag) => SELF_CLOSING.contains(tag.lexeme);
 
   /**
    * 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;
     List<XmlTagNode> tagNodes = parseTopTagNodes(token);
     return new HtmlUnit(token, tagNodes, currentToken);
   }
 
   /**
    * 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) {
+  bool _isScriptNode(
+      Token tag, List<XmlAttributeNode> attributes, List<XmlTagNode> tagNodes) {
     if (tagNodes.length != 0 || tag.lexeme != _SCRIPT) {
       return false;
     }
     for (XmlAttributeNode attribute in attributes) {
       if (attribute.name == _TYPE) {
         Token valueToken = attribute.valueToken;
         if (valueToken != null) {
           String value = valueToken.lexeme;
           if (value == _APPLICATION_DART_IN_DOUBLE_QUOTES ||
               value == _APPLICATION_DART_IN_SINGLE_QUOTES) {
             return true;
           }
         }
       }
     }
     return false;
   }
 
   /**
    * Given the contents of an embedded expression that occurs at the given offset, parse it as a
    * Dart expression. The contents should not include the expression's delimiters.
    *
    * @param source the source that contains that given token
    * @param token the token to start parsing from
    * @return the Dart expression that was parsed
    */
-  static Expression parseEmbeddedExpression(Source source, sc.Token token,
-      AnalysisErrorListener errorListener) {
+  static Expression parseEmbeddedExpression(
+      Source source, sc.Token token, AnalysisErrorListener errorListener) {
     Parser parser = new Parser(source, errorListener);
     return parser.parseExpression(token);
   }
 
   /**
    * Given the contents of an embedded expression that occurs at the given offset, scans it as a
    * Dart code.
    *
    * @param source the source of that contains the given contents
    * @param contents the contents to scan
    * @param contentOffset the offset of the contents in the larger file
    * @return the first Dart token
    */
   static sc.Token scanDartSource(Source source, LineInfo lineInfo,
       String contents, int contentOffset, AnalysisErrorListener errorListener) {
     LineInfo_Location location = lineInfo.getLocation(contentOffset);
-    sc.Scanner scanner = new sc.Scanner(
-        source,
-        new sc.SubSequenceReader(contents, contentOffset),
-        errorListener);
+    sc.Scanner scanner = new sc.Scanner(source,
+        new sc.SubSequenceReader(contents, contentOffset), errorListener);
     scanner.setSourceStart(location.lineNumber, location.columnNumber);
     return scanner.tokenize();
   }
 }
 
 /**
  * Instances of the class `HtmlScriptTagNode` represent a script tag within an HTML file that
  * references a Dart script.
  */
 class HtmlScriptTagNode extends XmlTagNode {
@@ skipping 15 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);
+      List<XmlTagNode> tagNodes, Token contentEnd, Token closingTag,
+      Token nodeEnd)
+      : super(nodeStart, tag, attributes, attributeEnd, tagNodes, contentEnd,
+          closingTag, nodeEnd);
 
   /**
    * 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 324 matching lines @@
 
   static const TokenType DIRECTIVE = const TokenType('DIRECTIVE', 8, null);
 
   static const TokenType STRING = const TokenType('STRING', 9, null);
 
   static const TokenType TAG = const TokenType('TAG', 10, null);
 
   static const TokenType TEXT = const TokenType('TEXT', 11, null);
 
   static const List<TokenType> values = const [
-      EOF,
-      EQ,
-      GT,
-      LT_SLASH,
-      LT,
-      SLASH_GT,
-      COMMENT,
-      DECLARATION,
-      DIRECTIVE,
-      STRING,
-      TAG,
-      TEXT];
+    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.
    */
   final String lexeme;
 
   const TokenType(String name, int ordinal, this.lexeme) : super(name, ordinal);
 }
 
@@ skipping 514 matching lines @@
    * @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
    * @return the node that was created
    */
   XmlTagNode createTagNode(Token nodeStart, Token tag,
       List<XmlAttributeNode> attributes, Token attributeEnd,
-      List<XmlTagNode> tagNodes, Token contentEnd, Token closingTag, Token nodeEnd) =>
-      new XmlTagNode(
-          nodeStart,
-          tag,
-          attributes,
-          attributeEnd,
-          tagNodes,
-          contentEnd,
-          closingTag,
-          nodeEnd);
+      List<XmlTagNode> tagNodes, Token contentEnd, Token closingTag,
+      Token nodeEnd) => new XmlTagNode(nodeStart, tag, attributes, attributeEnd,
+      tagNodes, contentEnd, closingTag, nodeEnd);
 
   /**
    * Answer `true` if the specified tag is self closing and thus should never have content or
    * child tag nodes.
    *
    * @param tag the tag (not `null`)
    * @return `true` if self closing
    */
   bool isSelfClosing(Token tag) => false;
 
@@ skipping 149 matching lines @@
     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 (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);
     }
     // Parse the child tag nodes
     List<XmlTagNode> tagNodes = _parseChildTagNodes();
     // Token ending child tag nodes
     Token contentEnd;
     if (_currentToken.type == TokenType.LT_SLASH) {
       contentEnd = _currentToken;
       _currentToken = _currentToken.next;
     } else {
       // TODO (danrubel): handle self closing HTML elements by inserting
@@ skipping 12 matching lines @@
     }
     // Token ending node
     Token nodeEnd;
     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);
+    return createTagNode(nodeStart, tag, attributes, attributeEnd, tagNodes,
+        contentEnd, closingTag, nodeEnd);
   }
 
   /**
    * Report the current token as unexpected
    */
   void _reportUnexpectedToken() {
     // TODO (danrubel): report unexpected token
   }
 }
 
@@ skipping 86 matching lines @@
    *          self closing or the attributeEnd is [TokenType.SLASH_GT], or
    *          * (3) [TokenType.EOF] if the node does not have a closing tag and is the last
    *          node in the stream [TokenType.LT_SLASH] token after the content, or `null`
    *          if there is no content and the attributes ended with [TokenType.SLASH_GT].
    * @param closingTag the closing [TokenType.TAG] after the child elements or `null` if
    *          there is no content and the attributes ended with [TokenType.SLASH_GT]
    * @param nodeEnd the ending [TokenType.GT] or [TokenType.SLASH_GT] token (not
    *          `null`)
    */
   XmlTagNode(this.nodeStart, this._tag, List<XmlAttributeNode> attributes,
-      this.attributeEnd, List<XmlTagNode> tagNodes, this.contentEnd, this.closingTag,
-      this.nodeEnd) {
+      this.attributeEnd, List<XmlTagNode> tagNodes, this.contentEnd,
+      this.closingTag, this.nodeEnd) {
     this._attributes = becomeParentOfAll(attributes, ifEmpty: NO_ATTRIBUTES);
     this._tagNodes = becomeParentOfAll(tagNodes, ifEmpty: NO_TAG_NODES);
   }
 
   /**
    * 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)
    */
@@ skipping 122 matching lines @@
  */
 abstract class XmlVisitor<R> {
   R visitHtmlScriptTagNode(HtmlScriptTagNode node);
 
   R visitHtmlUnit(HtmlUnit htmlUnit);
 
   R visitXmlAttributeNode(XmlAttributeNode xmlAttributeNode);
 
   R visitXmlTagNode(XmlTagNode xmlTagNode);
 }