Analyzer snapshot with disabled 'this.field' generation.

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 126 matching lines @@
 
   @override
   String toString() => lexeme;
 }
 
 /**
  * Implementation of [XmlExpression] for an [Expression] embedded without any wrapping
  * characters.
  */
 class RawXmlExpression extends XmlExpression {
-  final Expression expression;
+  Expression expression;
 
-  RawXmlExpression(this.expression);
+  RawXmlExpression(Expression expression) {
+    this.expression = expression;
+  }
 
   @override
   int get end => expression.end;
 
   @override
   int get length => expression.length;
 
   @override
   int get offset => expression.offset;
 
@@ skipping 515 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.
    */
-  final Source source;
+  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(this.source) {
+  AbstractScanner(Source source) {
+    this.source = 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 453 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.
    */
-  final String lexeme;
+  String lexeme;
 
-  TokenType(String name, int ordinal, this.lexeme) : super(name, ordinal);
+  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);
 
   @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 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) {
+  XmlAttributeNode(Token name, Token equals, Token value) {
     this._name = name;
+    this.equals = equals;
     this._value = value;
   }
 
   @override
   accept(XmlVisitor visitor) => visitor.visitXmlAttributeNode(this);
 
   @override
   Token get beginToken => _name;
 
   @override
@@ skipping 131 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.
    */
-  final Source source;
+  Source source;
 
   /**
    * The next token to be parsed.
    */
   Token _currentToken;
 
   /**
    * Construct a parser for the specified source.
    *
    * @param source the source being parsed
    */
-  XmlParser(this.source);
+  XmlParser(Source source) {
+    this.source = 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 235 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`).
    */
-  final Token nodeStart;
+  Token nodeStart;
 
   /**
    * The [TokenType#TAG] token after the starting '&lt;' (not `null`).
    */
   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].
    */
-  final Token attributeEnd;
+  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].
    */
-  final Token contentEnd;
+  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]
    */
-  final Token closingTag;
+  Token closingTag;
 
   /**
    * The ending [TokenType#GT] or [TokenType#SLASH_GT] token (not `null`).
    */
-  final Token nodeEnd;
+  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(this.nodeStart, Token tag, List<XmlAttributeNode> attributes, this.attributeEnd, List<XmlTagNode> tagNodes, this.contentEnd, this.closingTag, this.nodeEnd) {
+  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 = 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 243 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.
    */
-  final Token beginToken;
+  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].
    */
-  final Token endToken;
+  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(this.beginToken, List<XmlTagNode> tagNodes, this.endToken) {
+  HtmlUnit(Token beginToken, List<XmlTagNode> tagNodes, Token endToken) {
+    this.beginToken = beginToken;
     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);
     }
   }
 }