Rollback pkg/analyzer that breaks code_transformers

pkg/analyzer/lib/src/generated/ast.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.ast;
 
 import 'dart:collection';
@@ skipping 252 matching lines @@
    * @param atSign the at sign that introduced the annotation
    * @param name the name of the class defining the constructor that is being invoked or the name of
    *          the field that is being referenced
    * @param period the period before the constructor name, or `null` if this annotation is not
    *          the invocation of a named constructor
    * @param constructorName the name of the constructor being invoked, or `null` if this
    *          annotation is not the invocation of a named constructor
    * @param arguments the arguments to the constructor being invoked, or `null` if this
    *          annotation is not the invocation of a constructor
    */
-  Annotation(this.atSign, Identifier name, this.period, SimpleIdentifier constructorName, ArgumentList arguments) {
+  Annotation(Token atSign, Identifier name, Token period, SimpleIdentifier constructorName, ArgumentList arguments) {
+    this.atSign = atSign;
     this._name = becomeParentOf(name);
+    this.period = period;
     this._constructorName = becomeParentOf(constructorName);
     this._arguments = becomeParentOf(arguments);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitAnnotation(this);
 
   /**
    * Return the arguments to the constructor being invoked, or `null` if this annotation is
    * not the invocation of a constructor.
@@ skipping 110 matching lines @@
    * The identifier representing the argument being tested.
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created argument definition test.
    *
    * @param question the token representing the question mark
    * @param identifier the identifier representing the argument being tested
    */
-  ArgumentDefinitionTest(this.question, SimpleIdentifier identifier) {
+  ArgumentDefinitionTest(Token question, SimpleIdentifier identifier) {
+    this.question = question;
     this._identifier = becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitArgumentDefinitionTest(this);
 
   @override
   Token get beginToken => question;
 
   @override
@@ skipping 349 matching lines @@
 
   /**
    * Initialize a newly created assert statement.
    *
    * @param keyword the token representing the 'assert' keyword
    * @param leftParenthesis the left parenthesis
    * @param condition the condition that is being asserted to be `true`
    * @param rightParenthesis the right parenthesis
    * @param semicolon the semicolon terminating the statement
    */
-  AssertStatement(this.keyword, this.leftParenthesis, Expression condition, this.rightParenthesis, this.semicolon) {
+  AssertStatement(Token keyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon) {
+    this.keyword = keyword;
+    this.leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
+    this.rightParenthesis = rightParenthesis;
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitAssertStatement(this);
 
   @override
   Token get beginToken => keyword;
 
   /**
    * Return the condition that is being asserted to be `true`.
@@ skipping 58 matching lines @@
    */
   MethodElement _propagatedElement;
 
   /**
    * Initialize a newly created assignment expression.
    *
    * @param leftHandSide the expression used to compute the left hand side
    * @param operator the assignment operator being applied
    * @param rightHandSide the expression used to compute the right hand side
    */
-  AssignmentExpression(Expression leftHandSide, this.operator, Expression rightHandSide) {
+  AssignmentExpression(Expression leftHandSide, Token operator, Expression rightHandSide) {
     this._leftHandSide = becomeParentOf(leftHandSide);
+    this.operator = operator;
     this._rightHandSide = becomeParentOf(rightHandSide);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitAssignmentExpression(this);
 
   @override
   Token get beginToken => _leftHandSide.beginToken;
 
   /**
@@ skipping 624 matching lines @@
    */
   MethodElement _propagatedElement;
 
   /**
    * Initialize a newly created binary expression.
    *
    * @param leftOperand the expression used to compute the left operand
    * @param operator the binary operator being applied
    * @param rightOperand the expression used to compute the right operand
    */
-  BinaryExpression(Expression leftOperand, this.operator, Expression rightOperand) {
+  BinaryExpression(Expression leftOperand, Token operator, Expression rightOperand) {
     this._leftOperand = becomeParentOf(leftOperand);
+    this.operator = operator;
     this._rightOperand = becomeParentOf(rightOperand);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitBinaryExpression(this);
 
   @override
   Token get beginToken => _leftOperand.beginToken;
 
   /**
@@ skipping 163 matching lines @@
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created block of code.
    *
    * @param leftBracket the left curly bracket
    * @param statements the statements contained in the block
    * @param rightBracket the right curly bracket
    */
-  Block(this.leftBracket, List<Statement> statements, this.rightBracket) {
+  Block(Token leftBracket, List<Statement> statements, Token rightBracket) {
     this._statements = new NodeList<Statement>(this);
+    this.leftBracket = leftBracket;
     this._statements.addAll(statements);
+    this.rightBracket = rightBracket;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitBlock(this);
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Token get endToken => rightBracket;
@@ skipping 84 matching lines @@
    * The value of the literal.
    */
   bool value = false;
 
   /**
    * Initialize a newly created boolean literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
-  BooleanLiteral(this.literal, this.value);
+  BooleanLiteral(Token literal, bool value) {
+    this.literal = literal;
+    this.value = value;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitBooleanLiteral(this);
 
   @override
   Token get beginToken => literal;
 
   @override
   Token get endToken => literal;
 
@@ skipping 29 matching lines @@
    */
   Token semicolon;
 
   /**
    * Initialize a newly created break statement.
    *
    * @param keyword the token representing the 'break' keyword
    * @param label the label associated with the statement
    * @param semicolon the semicolon terminating the statement
    */
-  BreakStatement(this.keyword, SimpleIdentifier label, this.semicolon) {
+  BreakStatement(Token keyword, SimpleIdentifier label, Token semicolon) {
+    this.keyword = keyword;
     this._label = becomeParentOf(label);
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitBreakStatement(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => semicolon;
@@ skipping 170 matching lines @@
    * @param onKeyword the token representing the 'on' keyword
    * @param exceptionType the type of exceptions caught by this catch clause
    * @param leftParenthesis the left parenthesis
    * @param exceptionParameter the parameter whose value will be the exception that was thrown
    * @param comma the comma separating the exception parameter from the stack trace parameter
    * @param stackTraceParameter the parameter whose value will be the stack trace associated with
    *          the exception
    * @param rightParenthesis the right parenthesis
    * @param body the body of the catch block
    */
-  CatchClause(this.onKeyword, TypeName exceptionType, this.catchKeyword, Token leftParenthesis, SimpleIdentifier exceptionParameter, this.comma, SimpleIdentifier stackTraceParameter, Token rightParenthesis, Block body) {
+  CatchClause(Token onKeyword, TypeName exceptionType, Token catchKeyword, Token leftParenthesis, SimpleIdentifier exceptionParameter, Token comma, SimpleIdentifier stackTraceParameter, Token rightParenthesis, Block body) {
+    this.onKeyword = onKeyword;
     this.exceptionType = becomeParentOf(exceptionType);
+    this.catchKeyword = catchKeyword;
     this._leftParenthesis = leftParenthesis;
     this._exceptionParameter = becomeParentOf(exceptionParameter);
+    this.comma = comma;
     this._stackTraceParameter = becomeParentOf(stackTraceParameter);
     this._rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitCatchClause(this);
 
   @override
   Token get beginToken {
@@ skipping 176 matching lines @@
    * @param classKeyword the token representing the 'class' keyword
    * @param name the name of the class being declared
    * @param typeParameters the type parameters for the class
    * @param extendsClause the extends clause for the class
    * @param withClause the with clause for the class
    * @param implementsClause the implements clause for the class
    * @param leftBracket the left curly bracket
    * @param members the members defined by the class
    * @param rightBracket the right curly bracket
    */
-  ClassDeclaration(Comment comment, List<Annotation> metadata, this.abstractKeyword, this.classKeyword, SimpleIdentifier name, TypeParameterList typeParameters, ExtendsClause extendsClause, WithClause withClause, ImplementsClause implementsClause, this.leftBracket, List<ClassMember> members, this.rightBracket) : super(comment, metadata) {
+  ClassDeclaration(Comment comment, List<Annotation> metadata, Token abstractKeyword, Token classKeyword, SimpleIdentifier name, TypeParameterList typeParameters, ExtendsClause extendsClause, WithClause withClause, ImplementsClause implementsClause, Token leftBracket, List<ClassMember> members, Token rightBracket) : super(comment, metadata) {
     this._members = new NodeList<ClassMember>(this);
+    this.abstractKeyword = abstractKeyword;
+    this.classKeyword = classKeyword;
     this._name = becomeParentOf(name);
     this.typeParameters = becomeParentOf(typeParameters);
     this._extendsClause = becomeParentOf(extendsClause);
     this._withClause = becomeParentOf(withClause);
     this._implementsClause = becomeParentOf(implementsClause);
+    this.leftBracket = leftBracket;
     this._members.addAll(members);
+    this.rightBracket = rightBracket;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitClassDeclaration(this);
 
   /**
    * Return the constructor declared in the class with the given name.
    *
    * @param name the name of the constructor to find, `null` for default
    * @return the found constructor or `null` if not found
@@ skipping 226 matching lines @@
    * @param keyword the token representing the 'typedef' keyword
    * @param name the name of the class being declared
    * @param typeParameters the type parameters for the class
    * @param equals the token for the '=' separating the name from the definition
    * @param abstractKeyword the token for the 'abstract' keyword
    * @param superclass the name of the superclass of the class being declared
    * @param withClause the with clause for this class
    * @param implementsClause the implements clause for this class
    * @param semicolon the semicolon terminating the declaration
    */
-  ClassTypeAlias(Comment comment, List<Annotation> metadata, Token keyword, SimpleIdentifier name, TypeParameterList typeParameters, this.equals, this.abstractKeyword, TypeName superclass, WithClause withClause, ImplementsClause implementsClause, Token semicolon) : super(comment, metadata, keyword, semicolon) {
+  ClassTypeAlias(Comment comment, List<Annotation> metadata, Token keyword, SimpleIdentifier name, TypeParameterList typeParameters, Token equals, Token abstractKeyword, TypeName superclass, WithClause withClause, ImplementsClause implementsClause, Token semicolon) : super(comment, metadata, keyword, semicolon) {
     this._name = becomeParentOf(name);
     this._typeParameters = becomeParentOf(typeParameters);
+    this.equals = equals;
+    this.abstractKeyword = abstractKeyword;
     this._superclass = becomeParentOf(superclass);
     this._withClause = becomeParentOf(withClause);
     this._implementsClause = becomeParentOf(implementsClause);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitClassTypeAlias(this);
 
   @override
   ClassElement get element => _name != null ? (_name.staticElement as ClassElement) : null;
@@ skipping 105 matching lines @@
    * The keyword specifying what kind of processing is to be done on the imported names.
    */
   Token keyword;
 
   /**
    * Initialize a newly created import combinator.
    *
    * @param keyword the keyword specifying what kind of processing is to be done on the imported
    *          names
    */
-  Combinator(this.keyword);
+  Combinator(Token keyword) {
+    this.keyword = keyword;
+  }
 
   @override
   Token get beginToken => keyword;
 }
 
 /**
  * Instances of the class `Comment` represent a comment within the source code.
  *
  * <pre>
  * comment ::=
@@ skipping 42 matching lines @@
    * Create an end-of-line comment.
    *
    * @param tokens the tokens representing the comment
    * @return the end-of-line comment that was created
    */
   static Comment createEndOfLineComment(List<Token> tokens) => new Comment(tokens, CommentType.END_OF_LINE, null);
 
   /**
    * The tokens representing the comment.
    */
-  final List<Token> tokens;
+  List<Token> tokens;
 
   /**
    * The type of the comment.
    */
-  final CommentType _type;
+  CommentType _type;
 
   /**
    * The references embedded within the documentation comment. This list will be empty unless this
    * is a documentation comment that has references embedded within it.
    */
   NodeList<CommentReference> _references;
 
   /**
    * Initialize a newly created comment.
    *
    * @param tokens the tokens representing the comment
    * @param type the type of the comment
    * @param references the references embedded within the documentation comment
    */
-  Comment(this.tokens, this._type, List<CommentReference> references) {
+  Comment(List<Token> tokens, CommentType type, List<CommentReference> references) {
     this._references = new NodeList<CommentReference>(this);
+    this.tokens = tokens;
+    this._type = type;
     this._references.addAll(references);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitComment(this);
 
   @override
   Token get beginToken => tokens[0];
 
   @override
@@ skipping 34 matching lines @@
 }
 
 /**
  * The enumeration `CommentType` encodes all the different types of comments that are
  * recognized by the parser.
  */
 class CommentType extends Enum<CommentType> {
   /**
    * An end-of-line comment.
    */
-  static const CommentType END_OF_LINE = const CommentType('END_OF_LINE', 0);
+  static final CommentType END_OF_LINE = new CommentType('END_OF_LINE', 0);
 
   /**
    * A block comment.
    */
-  static const CommentType BLOCK = const CommentType('BLOCK', 1);
+  static final CommentType BLOCK = new CommentType('BLOCK', 1);
 
   /**
    * A documentation comment.
    */
-  static const CommentType DOCUMENTATION = const CommentType('DOCUMENTATION', 2);
+  static final CommentType DOCUMENTATION = new CommentType('DOCUMENTATION', 2);
 
-  static const List<CommentType> values = const [END_OF_LINE, BLOCK, DOCUMENTATION];
+  static final List<CommentType> values = [END_OF_LINE, BLOCK, DOCUMENTATION];
 
-  const CommentType(String name, int ordinal) : super(name, ordinal);
+  CommentType(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * Instances of the class `CommentReference` represent a reference to a Dart element that is
  * found within a documentation comment.
  *
  * <pre>
  * commentReference ::=
  *     '[' 'new'? [Identifier] ']'
  * </pre>
  */
 class CommentReference extends AstNode {
   /**
    * The token representing the 'new' keyword, or `null` if there was no 'new' keyword.
    */
   Token newKeyword;
 
   /**
    * The identifier being referenced.
    */
   Identifier _identifier;
 
   /**
    * Initialize a newly created reference to a Dart element.
    *
    * @param newKeyword the token representing the 'new' keyword
    * @param identifier the identifier being referenced
    */
-  CommentReference(this.newKeyword, Identifier identifier) {
+  CommentReference(Token newKeyword, Identifier identifier) {
+    this.newKeyword = newKeyword;
     this._identifier = becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitCommentReference(this);
 
   @override
   Token get beginToken => _identifier.beginToken;
 
   @override
@@ skipping 42 matching lines @@
  *   | [ExportDirective]
  *
  * declarations ::=
  *     [CompilationUnitMember]*
  * </pre>
  */
 class CompilationUnit extends AstNode {
   /**
    * The first token in the token stream that was parsed to form this compilation unit.
    */
-  final Token beginToken;
+  Token beginToken;
 
   /**
    * The script tag at the beginning of the compilation unit, or `null` if there is no script
    * tag in this compilation unit.
    */
   ScriptTag _scriptTag;
 
   /**
    * The directives contained in this compilation unit.
    */
   NodeList<Directive> _directives;
 
   /**
    * The declarations contained in this compilation unit.
    */
   NodeList<CompilationUnitMember> _declarations;
 
   /**
    * 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 element associated with this compilation unit, or `null` if the AST structure has not
    * been resolved.
    */
   CompilationUnitElement element;
 
   /**
    * The line information for this compilation unit.
    */
   LineInfo lineInfo;
 
   /**
    * Initialize a newly created compilation unit to have the given directives and declarations.
    *
    * @param beginToken the first token in the token stream
    * @param scriptTag the script tag at the beginning of the compilation unit
    * @param directives the directives contained in this compilation unit
    * @param declarations the declarations contained in this compilation unit
    * @param endToken the last token in the token stream
    */
-  CompilationUnit(this.beginToken, ScriptTag scriptTag, List<Directive> directives, List<CompilationUnitMember> declarations, this.endToken) {
+  CompilationUnit(Token beginToken, ScriptTag scriptTag, List<Directive> directives, List<CompilationUnitMember> declarations, Token endToken) {
     this._directives = new NodeList<Directive>(this);
     this._declarations = new NodeList<CompilationUnitMember>(this);
+    this.beginToken = beginToken;
     this._scriptTag = becomeParentOf(scriptTag);
     this._directives.addAll(directives);
     this._declarations.addAll(declarations);
+    this.endToken = endToken;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitCompilationUnit(this);
 
   /**
    * Return the declarations contained in this compilation unit.
    *
    * @return the declarations contained in this compilation unit
    */
@@ skipping 141 matching lines @@
    * Initialize a newly created conditional expression.
    *
    * @param condition the condition used to determine which expression is executed next
    * @param question the token used to separate the condition from the then expression
    * @param thenExpression the expression that is executed if the condition evaluates to
    *          `true`
    * @param colon the token used to separate the then expression from the else expression
    * @param elseExpression the expression that is executed if the condition evaluates to
    *          `false`
    */
-  ConditionalExpression(Expression condition, this.question, Expression thenExpression, this.colon, Expression elseExpression) {
+  ConditionalExpression(Expression condition, Token question, Expression thenExpression, Token colon, Expression elseExpression) {
     this._condition = becomeParentOf(condition);
+    this.question = question;
     this._thenExpression = becomeParentOf(thenExpression);
+    this.colon = colon;
     this._elseExpression = becomeParentOf(elseExpression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitConditionalExpression(this);
 
   @override
   Token get beginToken => _condition.beginToken;
 
   /**
@@ skipping 163 matching lines @@
    * @param returnType the return type of the constructor
    * @param period the token for the period before the constructor name
    * @param name the name of the constructor
    * @param parameters the parameters associated with the constructor
    * @param separator the token for the colon or equals before the initializers
    * @param initializers the initializers associated with the constructor
    * @param redirectedConstructor the name of the constructor to which this constructor will be
    *          redirected
    * @param body the body of the constructor
    */
-  ConstructorDeclaration(Comment comment, List<Annotation> metadata, this.externalKeyword, this.constKeyword, this.factoryKeyword, Identifier returnType, this.period, SimpleIdentifier name, FormalParameterList parameters, this.separator, List<ConstructorInitializer> initializers, ConstructorName redirectedConstructor, FunctionBody body) : super(comment, metadata) {
+  ConstructorDeclaration(Comment comment, List<Annotation> metadata, Token externalKeyword, Token constKeyword, Token factoryKeyword, Identifier returnType, Token period, SimpleIdentifier name, FormalParameterList parameters, Token separator, List<ConstructorInitializer> initializers, ConstructorName redirectedConstructor, FunctionBody body) : super(comment, metadata) {
     this._initializers = new NodeList<ConstructorInitializer>(this);
+    this.externalKeyword = externalKeyword;
+    this.constKeyword = constKeyword;
+    this.factoryKeyword = factoryKeyword;
     this._returnType = becomeParentOf(returnType);
+    this.period = period;
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
+    this.separator = separator;
     this._initializers.addAll(initializers);
     this._redirectedConstructor = becomeParentOf(redirectedConstructor);
     this._body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitConstructorDeclaration(this);
 
   /**
    * Return the body of the constructor, or `null` if the constructor does not have a body.
@@ skipping 176 matching lines @@
   /**
    * Initialize a newly created field initializer to initialize the field with the given name to the
    * value of the given expression.
    *
    * @param keyword the token for the 'this' keyword
    * @param period the token for the period after the 'this' keyword
    * @param fieldName the name of the field being initialized
    * @param equals the token for the equal sign between the field name and the expression
    * @param expression the expression computing the value to which the field will be initialized
    */
-  ConstructorFieldInitializer(this.keyword, this.period, SimpleIdentifier fieldName, this.equals, Expression expression) {
+  ConstructorFieldInitializer(Token keyword, Token period, SimpleIdentifier fieldName, Token equals, Expression expression) {
+    this.keyword = keyword;
+    this.period = period;
     this._fieldName = becomeParentOf(fieldName);
+    this.equals = equals;
     this._expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitConstructorFieldInitializer(this);
 
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
@@ skipping 90 matching lines @@
    */
   ConstructorElement _staticElement;
 
   /**
    * Initialize a newly created constructor name.
    *
    * @param type the name of the type defining the constructor
    * @param period the token for the period before the constructor name
    * @param name the name of the constructor
    */
-  ConstructorName(TypeName type, this.period, SimpleIdentifier name) {
+  ConstructorName(TypeName type, Token period, SimpleIdentifier name) {
     this._type = becomeParentOf(type);
+    this.period = period;
     this._name = becomeParentOf(name);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitConstructorName(this);
 
   @override
   Token get beginToken => _type.beginToken;
 
   @override
@@ skipping 87 matching lines @@
    */
   Token semicolon;
 
   /**
    * Initialize a newly created continue statement.
    *
    * @param keyword the token representing the 'continue' keyword
    * @param label the label associated with the statement
    * @param semicolon the semicolon terminating the statement
    */
-  ContinueStatement(this.keyword, SimpleIdentifier label, this.semicolon) {
+  ContinueStatement(Token keyword, SimpleIdentifier label, Token semicolon) {
+    this.keyword = keyword;
     this._label = becomeParentOf(label);
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitContinueStatement(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => semicolon;
@@ skipping 71 matching lines @@
 
   /**
    * Initialize a newly created formal parameter.
    *
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    * @param type the name of the declared type of the parameter
    * @param identifier the name of the parameter being declared
    */
-  DeclaredIdentifier(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, SimpleIdentifier identifier) : super(comment, metadata) {
+  DeclaredIdentifier(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, SimpleIdentifier identifier) : super(comment, metadata) {
+    this.keyword = keyword;
     this._type = becomeParentOf(type);
     this._identifier = becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitDeclaredIdentifier(this);
 
   @override
   LocalVariableElement get element {
     SimpleIdentifier identifier = this.identifier;
@@ skipping 101 matching lines @@
   Expression _defaultValue;
 
   /**
    * Initialize a newly created default formal parameter.
    *
    * @param parameter the formal parameter with which the default value is associated
    * @param kind the kind of this parameter
    * @param separator the token separating the parameter from the default value
    * @param defaultValue the expression computing the default value for the parameter
    */
-  DefaultFormalParameter(NormalFormalParameter parameter, this.kind, this.separator, Expression defaultValue) {
+  DefaultFormalParameter(NormalFormalParameter parameter, ParameterKind kind, Token separator, Expression defaultValue) {
     this._parameter = becomeParentOf(parameter);
+    this.kind = kind;
+    this.separator = separator;
     this._defaultValue = becomeParentOf(defaultValue);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitDefaultFormalParameter(this);
 
   @override
   Token get beginToken => _parameter.beginToken;
 
   /**
@@ skipping 156 matching lines @@
    * Initialize a newly created do loop.
    *
    * @param doKeyword the token representing the 'do' keyword
    * @param body the body of the loop
    * @param whileKeyword the token representing the 'while' keyword
    * @param leftParenthesis the left parenthesis
    * @param condition the condition that determines when the loop will terminate
    * @param rightParenthesis the right parenthesis
    * @param semicolon the semicolon terminating the statement
    */
-  DoStatement(this.doKeyword, Statement body, this.whileKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, this.semicolon) {
+  DoStatement(Token doKeyword, Statement body, Token whileKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon) {
+    this.doKeyword = doKeyword;
     this._body = becomeParentOf(body);
+    this.whileKeyword = whileKeyword;
     this._leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
     this._rightParenthesis = rightParenthesis;
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitDoStatement(this);
 
   @override
   Token get beginToken => doKeyword;
 
   /**
    * Return the body of the loop.
@@ skipping 91 matching lines @@
    * The value of the literal.
    */
   double value = 0.0;
 
   /**
    * Initialize a newly created floating point literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
-  DoubleLiteral(this.literal, this.value);
+  DoubleLiteral(Token literal, double value) {
+    this.literal = literal;
+    this.value = value;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitDoubleLiteral(this);
 
   @override
   Token get beginToken => literal;
 
   @override
   Token get endToken => literal;
 
@@ skipping 15 matching lines @@
   /**
    * The token representing the semicolon that marks the end of the function body.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created function body.
    *
    * @param semicolon the token representing the semicolon that marks the end of the function body
    */
-  EmptyFunctionBody(this.semicolon);
+  EmptyFunctionBody(Token semicolon) {
+    this.semicolon = semicolon;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitEmptyFunctionBody(this);
 
   @override
   Token get beginToken => semicolon;
 
   @override
   Token get endToken => semicolon;
 
@@ skipping 14 matching lines @@
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created empty statement.
    *
    * @param semicolon the semicolon terminating the statement
    */
-  EmptyStatement(this.semicolon);
+  EmptyStatement(Token semicolon) {
+    this.semicolon = semicolon;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitEmptyStatement(this);
 
   @override
   Token get beginToken => semicolon;
 
   @override
   Token get endToken => semicolon;
 
@@ skipping 237 matching lines @@
   Token semicolon;
 
   /**
    * Initialize a newly created function body consisting of a block of statements.
    *
    * @param functionDefinition the token introducing the expression that represents the body of the
    *          function
    * @param expression the expression representing the body of the function
    * @param semicolon the semicolon terminating the statement
    */
-  ExpressionFunctionBody(this.functionDefinition, Expression expression, this.semicolon) {
+  ExpressionFunctionBody(Token functionDefinition, Expression expression, Token semicolon) {
+    this.functionDefinition = functionDefinition;
     this._expression = becomeParentOf(expression);
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitExpressionFunctionBody(this);
 
   @override
   Token get beginToken => functionDefinition;
 
   @override
   Token get endToken {
@@ skipping 44 matching lines @@
    * expression and therefore isn't followed by a semicolon.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created expression statement.
    *
    * @param expression the expression that comprises the statement
    * @param semicolon the semicolon terminating the statement
    */
-  ExpressionStatement(Expression expression, this.semicolon) {
+  ExpressionStatement(Expression expression, Token semicolon) {
     this._expression = becomeParentOf(expression);
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitExpressionStatement(this);
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Token get endToken {
@@ skipping 47 matching lines @@
    * The name of the class that is being extended.
    */
   TypeName _superclass;
 
   /**
    * Initialize a newly created extends clause.
    *
    * @param keyword the token representing the 'extends' keyword
    * @param superclass the name of the class that is being extended
    */
-  ExtendsClause(this.keyword, TypeName superclass) {
+  ExtendsClause(Token keyword, TypeName superclass) {
+    this.keyword = keyword;
     this._superclass = becomeParentOf(superclass);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitExtendsClause(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
@@ skipping 48 matching lines @@
 
   /**
    * Initialize a newly created field declaration.
    *
    * @param comment the documentation comment associated with this field
    * @param metadata the annotations associated with this field
    * @param staticKeyword the token representing the 'static' keyword
    * @param fieldList the fields being declared
    * @param semicolon the semicolon terminating the declaration
    */
-  FieldDeclaration(Comment comment, List<Annotation> metadata, this.staticKeyword, VariableDeclarationList fieldList, this.semicolon) : super(comment, metadata) {
+  FieldDeclaration(Comment comment, List<Annotation> metadata, Token staticKeyword, VariableDeclarationList fieldList, Token semicolon) : super(comment, metadata) {
+    this.staticKeyword = staticKeyword;
     this._fieldList = becomeParentOf(fieldList);
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFieldDeclaration(this);
 
   @override
   Element get element => null;
 
   @override
   Token get endToken => semicolon;
@@ skipping 79 matching lines @@
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    * @param type the name of the declared type of the parameter
    * @param thisToken the token representing the 'this' keyword
    * @param period the token representing the period
    * @param identifier the name of the parameter being declared
    * @param parameters the parameters of the function-typed parameter, or `null` if this is
    *          not a function-typed field formal parameter
    */
-  FieldFormalParameter(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, this.thisToken, this.period, SimpleIdentifier identifier, FormalParameterList parameters) : super(comment, metadata, identifier) {
+  FieldFormalParameter(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, Token thisToken, Token period, SimpleIdentifier identifier, FormalParameterList parameters) : super(comment, metadata, identifier) {
+    this.keyword = keyword;
     this._type = becomeParentOf(type);
+    this.thisToken = thisToken;
+    this.period = period;
     this._parameters = becomeParentOf(parameters);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFieldFormalParameter(this);
 
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
@@ skipping 110 matching lines @@
   /**
    * Initialize a newly created for-each statement.
    *
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
    * @param loopVariable the declaration of the loop variable
    * @param iterator the expression evaluated to produce the iterator
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
-  ForEachStatement.con1(this.forKeyword, this.leftParenthesis, DeclaredIdentifier loopVariable, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
+  ForEachStatement.con1(Token forKeyword, Token leftParenthesis, DeclaredIdentifier loopVariable, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body) {
+    this.forKeyword = forKeyword;
+    this.leftParenthesis = leftParenthesis;
     this._loopVariable = becomeParentOf(loopVariable);
+    this.inKeyword = inKeyword;
     this._iterator = becomeParentOf(iterator);
+    this.rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
 
   /**
    * Initialize a newly created for-each statement.
    *
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
    * @param identifier the loop variable
    * @param iterator the expression evaluated to produce the iterator
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
-  ForEachStatement.con2(this.forKeyword, this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
+  ForEachStatement.con2(Token forKeyword, Token leftParenthesis, SimpleIdentifier identifier, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body) {
+    this.forKeyword = forKeyword;
+    this.leftParenthesis = leftParenthesis;
     this._identifier = becomeParentOf(identifier);
+    this.inKeyword = inKeyword;
     this._iterator = becomeParentOf(iterator);
+    this.rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitForEachStatement(this);
 
   @override
   Token get beginToken => forKeyword;
 
   /**
@@ skipping 151 matching lines @@
    * @param leftParenthesis the left parenthesis
    * @param variableList the declaration of the loop variables
    * @param initialization the initialization expression
    * @param leftSeparator the semicolon separating the initializer and the condition
    * @param condition the condition used to determine when to terminate the loop
    * @param rightSeparator the semicolon separating the condition and the updater
    * @param updaters the list of expressions run after each execution of the loop body
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
-  ForStatement(this.forKeyword, this.leftParenthesis, VariableDeclarationList variableList, Expression initialization, this.leftSeparator, Expression condition, this.rightSeparator, List<Expression> updaters, this.rightParenthesis, Statement body) {
+  ForStatement(Token forKeyword, Token leftParenthesis, VariableDeclarationList variableList, Expression initialization, Token leftSeparator, Expression condition, Token rightSeparator, List<Expression> updaters, Token rightParenthesis, Statement body) {
     this._updaters = new NodeList<Expression>(this);
+    this.forKeyword = forKeyword;
+    this.leftParenthesis = leftParenthesis;
     this._variableList = becomeParentOf(variableList);
     this._initialization = becomeParentOf(initialization);
+    this.leftSeparator = leftSeparator;
     this._condition = becomeParentOf(condition);
+    this.rightSeparator = rightSeparator;
     this._updaters.addAll(updaters);
+    this.rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitForStatement(this);
 
   @override
   Token get beginToken => forKeyword;
 
   /**
@@ skipping 378 matching lines @@
    * Initialize a newly created function declaration.
    *
    * @param comment the documentation comment associated with this function
    * @param metadata the annotations associated with this function
    * @param externalKeyword the token representing the 'external' keyword
    * @param returnType the return type of the function
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param name the name of the function
    * @param functionExpression the function expression being wrapped
    */
-  FunctionDeclaration(Comment comment, List<Annotation> metadata, this.externalKeyword, TypeName returnType, this.propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression) : super(comment, metadata) {
+  FunctionDeclaration(Comment comment, List<Annotation> metadata, Token externalKeyword, TypeName returnType, Token propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression) : super(comment, metadata) {
+    this.externalKeyword = externalKeyword;
     this._returnType = becomeParentOf(returnType);
+    this.propertyKeyword = propertyKeyword;
     this._name = becomeParentOf(name);
     this._functionExpression = becomeParentOf(functionExpression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitFunctionDeclaration(this);
 
   @override
   ExecutableElement get element => _name != null ? (_name.staticElement as ExecutableElement) : null;
 
@@ skipping 761 matching lines @@
    * Initialize a newly created if statement.
    *
    * @param ifKeyword the token representing the 'if' keyword
    * @param leftParenthesis the left parenthesis
    * @param condition the condition used to determine which of the statements is executed next
    * @param rightParenthesis the right parenthesis
    * @param thenStatement the statement that is executed if the condition evaluates to `true`
    * @param elseKeyword the token representing the 'else' keyword
    * @param elseStatement the statement that is executed if the condition evaluates to `false`
    */
-  IfStatement(this.ifKeyword, this.leftParenthesis, Expression condition, this.rightParenthesis, Statement thenStatement, this.elseKeyword, Statement elseStatement) {
+  IfStatement(Token ifKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Statement thenStatement, Token elseKeyword, Statement elseStatement) {
+    this.ifKeyword = ifKeyword;
+    this.leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
+    this.rightParenthesis = rightParenthesis;
     this._thenStatement = becomeParentOf(thenStatement);
+    this.elseKeyword = elseKeyword;
     this._elseStatement = becomeParentOf(elseStatement);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitIfStatement(this);
 
   @override
   Token get beginToken => ifKeyword;
 
   /**
@@ skipping 83 matching lines @@
    * The interfaces that are being implemented.
    */
   NodeList<TypeName> _interfaces;
 
   /**
    * Initialize a newly created implements clause.
    *
    * @param keyword the token representing the 'implements' keyword
    * @param interfaces the interfaces that are being implemented
    */
-  ImplementsClause(this.keyword, List<TypeName> interfaces) {
+  ImplementsClause(Token keyword, List<TypeName> interfaces) {
     this._interfaces = new NodeList<TypeName>(this);
+    this.keyword = keyword;
     this._interfaces.addAll(interfaces);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitImplementsClause(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
@@ skipping 128 matching lines @@
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param keyword the token representing the 'import' keyword
    * @param libraryUri the URI of the library being imported
    * @param asToken the token representing the 'as' token
    * @param prefix the prefix to be used with the imported names
    * @param combinators the combinators used to control how names are imported
    * @param semicolon the semicolon terminating the directive
    */
-  ImportDirective(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, this.asToken, SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon) : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
+  ImportDirective(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, Token asToken, SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon) : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
+    this.asToken = asToken;
     this._prefix = becomeParentOf(prefix);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitImportDirective(this);
 
   @override
   ImportElement get element => super.element as ImportElement;
 
   /**
@@ skipping 103 matching lines @@
   }
 
   /**
    * Initialize a newly created index expression.
    *
    * @param period the period ("..") before a cascaded index expression
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
-  IndexExpression.forCascade(this.period, Token leftBracket, Expression index, Token rightBracket) {
+  IndexExpression.forCascade(Token period, Token leftBracket, Expression index, Token rightBracket) {
+    this.period = period;
     this._leftBracket = leftBracket;
     this._index = becomeParentOf(index);
     this._rightBracket = rightBracket;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitIndexExpression(this);
 
   @override
   Token get beginToken {
@@ skipping 288 matching lines @@
    */
   ConstructorElement staticElement;
 
   /**
    * Initialize a newly created instance creation expression.
    *
    * @param keyword the keyword used to indicate how an object should be created
    * @param constructorName the name of the constructor to be invoked
    * @param argumentList the list of arguments to the constructor
    */
-  InstanceCreationExpression(this.keyword, ConstructorName constructorName, ArgumentList argumentList) {
+  InstanceCreationExpression(Token keyword, ConstructorName constructorName, ArgumentList argumentList) {
+    this.keyword = keyword;
     this.constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitInstanceCreationExpression(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
@@ skipping 59 matching lines @@
    * The value of the literal.
    */
   int value = 0;
 
   /**
    * Initialize a newly created integer literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
-  IntegerLiteral(this.literal, this.value);
+  IntegerLiteral(Token literal, int value) {
+    this.literal = literal;
+    this.value = value;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitIntegerLiteral(this);
 
   @override
   Token get beginToken => literal;
 
   @override
   Token get endToken => literal;
 
@@ skipping 42 matching lines @@
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created interpolation expression.
    *
    * @param leftBracket the left curly bracket
    * @param expression the expression to be evaluated for the value to be converted into a string
    * @param rightBracket the right curly bracket
    */
-  InterpolationExpression(this.leftBracket, Expression expression, this.rightBracket) {
+  InterpolationExpression(Token leftBracket, Expression expression, Token rightBracket) {
+    this.leftBracket = leftBracket;
     this._expression = becomeParentOf(expression);
+    this.rightBracket = rightBracket;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitInterpolationExpression(this);
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Token get endToken {
@@ skipping 133 matching lines @@
   TypeName _type;
 
   /**
    * Initialize a newly created is expression.
    *
    * @param expression the expression used to compute the value whose type is being tested
    * @param isOperator the is operator
    * @param notOperator the not operator, or `null` if the sense of the test is not negated
    * @param type the name of the type being tested for
    */
-  IsExpression(Expression expression, this.isOperator, this.notOperator, TypeName type) {
+  IsExpression(Expression expression, Token isOperator, Token notOperator, TypeName type) {
     this._expression = becomeParentOf(expression);
+    this.isOperator = isOperator;
+    this.notOperator = notOperator;
     this._type = becomeParentOf(type);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitIsExpression(this);
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
@@ skipping 60 matching lines @@
    * The colon that separates the label from the statement.
    */
   Token colon;
 
   /**
    * Initialize a newly created label.
    *
    * @param label the label being applied
    * @param colon the colon that separates the label from whatever follows
    */
-  Label(SimpleIdentifier label, this.colon) {
+  Label(SimpleIdentifier label, Token colon) {
     this._label = becomeParentOf(label);
+    this.colon = colon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitLabel(this);
 
   @override
   Token get beginToken => _label.beginToken;
 
   @override
   Token get endToken => colon;
@@ skipping 122 matching lines @@
 
   /**
    * Initialize a newly created library directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param libraryToken the token representing the 'library' token
    * @param name the name of the library being defined
    * @param semicolon the semicolon terminating the directive
    */
-  LibraryDirective(Comment comment, List<Annotation> metadata, this.libraryToken, LibraryIdentifier name, this.semicolon) : super(comment, metadata) {
+  LibraryDirective(Comment comment, List<Annotation> metadata, Token libraryToken, LibraryIdentifier name, Token semicolon) : super(comment, metadata) {
+    this.libraryToken = libraryToken;
     this._name = becomeParentOf(name);
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitLibraryDirective(this);
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get keyword => libraryToken;
@@ skipping 354 matching lines @@
    */
   Expression _value;
 
   /**
    * Initialize a newly created map literal entry.
    *
    * @param key the expression computing the key with which the value will be associated
    * @param separator the colon that separates the key from the value
    * @param value the expression computing the value that will be associated with the key
    */
-  MapLiteralEntry(Expression key, this.separator, Expression value) {
+  MapLiteralEntry(Expression key, Token separator, Expression value) {
     this._key = becomeParentOf(key);
+    this.separator = separator;
     this._value = becomeParentOf(value);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitMapLiteralEntry(this);
 
   @override
   Token get beginToken => _key.beginToken;
 
   @override
@@ skipping 108 matching lines @@
    * @param metadata the annotations associated with this method
    * @param modifierKeyword the token representing the 'abstract' or 'static' keyword
    * @param returnType the return type of the method
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param operatorKeyword the token representing the 'operator' keyword
    * @param name the name of the method
    * @param parameters the parameters associated with the method, or `null` if this method
    *          declares a getter
    * @param body the body of the method
    */
-  MethodDeclaration(Comment comment, List<Annotation> metadata, this.externalKeyword, this.modifierKeyword, TypeName returnType, this.propertyKeyword, this.operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body) : super(comment, metadata) {
+  MethodDeclaration(Comment comment, List<Annotation> metadata, Token externalKeyword, Token modifierKeyword, TypeName returnType, Token propertyKeyword, Token operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body) : super(comment, metadata) {
+    this.externalKeyword = externalKeyword;
+    this.modifierKeyword = modifierKeyword;
     this._returnType = becomeParentOf(returnType);
+    this.propertyKeyword = propertyKeyword;
+    this.operatorKeyword = operatorKeyword;
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
     this._body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitMethodDeclaration(this);
 
   /**
    * Return the body of the method.
@@ skipping 169 matching lines @@
   ArgumentList _argumentList;
 
   /**
    * Initialize a newly created method invocation.
    *
    * @param target the expression producing the object on which the method is defined
    * @param period the period that separates the target from the method name
    * @param methodName the name of the method being invoked
    * @param argumentList the list of arguments to the method
    */
-  MethodInvocation(Expression target, this.period, SimpleIdentifier methodName, ArgumentList argumentList) {
+  MethodInvocation(Expression target, Token period, SimpleIdentifier methodName, ArgumentList argumentList) {
     this._target = becomeParentOf(target);
+    this.period = period;
     this._methodName = becomeParentOf(methodName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitMethodInvocation(this);
 
   /**
    * Return the list of arguments to the method.
    *
@@ skipping 227 matching lines @@
   /**
    * Initialize a newly created namespace directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param keyword the token representing the 'import' or 'export' keyword
    * @param libraryUri the URI of the library being imported or exported
    * @param combinators the combinators used to control which names are imported or exported
    * @param semicolon the semicolon terminating the directive
    */
-  NamespaceDirective(Comment comment, List<Annotation> metadata, this.keyword, StringLiteral libraryUri, List<Combinator> combinators, this.semicolon) : super(comment, metadata, libraryUri) {
+  NamespaceDirective(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon) : super(comment, metadata, libraryUri) {
     this._combinators = new NodeList<Combinator>(this);
+    this.keyword = keyword;
     this._combinators.addAll(combinators);
+    this.semicolon = semicolon;
   }
 
   /**
    * Return the combinators used to control how names are imported or exported.
    *
    * @return the combinators used to control how names are imported or exported
    */
   NodeList<Combinator> get combinators => _combinators;
 
   @override
@@ skipping 25 matching lines @@
    * The name of the native object that implements the class.
    */
   StringLiteral name;
 
   /**
    * Initialize a newly created native clause.
    *
    * @param keyword the token representing the 'native' keyword
    * @param name the name of the native object that implements the class.
    */
-  NativeClause(this.keyword, this.name);
+  NativeClause(Token keyword, StringLiteral name) {
+    this.keyword = keyword;
+    this.name = name;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitNativeClause(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => name.endToken;
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(name, visitor);
   }
 }
 
 /**
  * Instances of the class `NativeFunctionBody` represent a function body that consists of a
  * native keyword followed by a string literal.
  *
  * <pre>
  * nativeFunctionBody ::=
  *     'native' [SimpleStringLiteral] ';'
  * </pre>
  */
 class NativeFunctionBody extends FunctionBody {
   /**
    * The token representing 'native' that marks the start of the function body.
    */
-  final Token nativeToken;
+  Token nativeToken;
 
   /**
    * The string literal, after the 'native' token.
    */
   StringLiteral _stringLiteral;
 
   /**
    * The token representing the semicolon that marks the end of the function body.
    */
-  final Token semicolon;
+  Token semicolon;
 
   /**
    * Initialize a newly created function body consisting of the 'native' token, a string literal,
    * and a semicolon.
    *
    * @param nativeToken the token representing 'native' that marks the start of the function body
    * @param stringLiteral the string literal
    * @param semicolon the token representing the semicolon that marks the end of the function body
    */
-  NativeFunctionBody(this.nativeToken, StringLiteral stringLiteral, this.semicolon) {
+  NativeFunctionBody(Token nativeToken, StringLiteral stringLiteral, Token semicolon) {
+    this.nativeToken = nativeToken;
     this._stringLiteral = becomeParentOf(stringLiteral);
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitNativeFunctionBody(this);
 
   @override
   Token get beginToken => nativeToken;
 
   @override
   Token get endToken => semicolon;
@@ skipping 305 matching lines @@
 
   /**
    * Initialize a newly created part directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param partToken the token representing the 'part' token
    * @param partUri the URI of the part being included
    * @param semicolon the semicolon terminating the directive
    */
-  PartDirective(Comment comment, List<Annotation> metadata, this.partToken, StringLiteral partUri, this.semicolon) : super(comment, metadata, partUri);
+  PartDirective(Comment comment, List<Annotation> metadata, Token partToken, StringLiteral partUri, Token semicolon) : super(comment, metadata, partUri) {
+    this.partToken = partToken;
+    this.semicolon = semicolon;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPartDirective(this);
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get keyword => partToken;
 
@@ skipping 36 matching lines @@
   /**
    * Initialize a newly created part-of directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param partToken the token representing the 'part' token
    * @param ofToken the token representing the 'of' token
    * @param libraryName the name of the library that the containing compilation unit is part of
    * @param semicolon the semicolon terminating the directive
    */
-  PartOfDirective(Comment comment, List<Annotation> metadata, this.partToken, this.ofToken, LibraryIdentifier libraryName, this.semicolon) : super(comment, metadata) {
+  PartOfDirective(Comment comment, List<Annotation> metadata, Token partToken, Token ofToken, LibraryIdentifier libraryName, Token semicolon) : super(comment, metadata) {
+    this.partToken = partToken;
+    this.ofToken = ofToken;
     this._libraryName = becomeParentOf(libraryName);
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPartOfDirective(this);
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get keyword => partToken;
@@ skipping 56 matching lines @@
    * or if the operator could not be resolved.
    */
   MethodElement _staticElement;
 
   /**
    * Initialize a newly created postfix expression.
    *
    * @param operand the expression computing the operand for the operator
    * @param operator the postfix operator being applied to the operand
    */
-  PostfixExpression(Expression operand, this.operator) {
+  PostfixExpression(Expression operand, Token operator) {
     this._operand = becomeParentOf(operand);
+    this.operator = operator;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPostfixExpression(this);
 
   @override
   Token get beginToken => _operand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
@@ skipping 153 matching lines @@
    * or if the operator could not be resolved.
    */
   MethodElement _propagatedElement;
 
   /**
    * Initialize a newly created prefix expression.
    *
    * @param operator the prefix operator being applied to the operand
    * @param operand the expression computing the operand for the operator
    */
-  PrefixExpression(this.operator, Expression operand) {
+  PrefixExpression(Token operator, Expression operand) {
+    this.operator = operator;
     this._operand = becomeParentOf(operand);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPrefixExpression(this);
 
   @override
   Token get beginToken => operator;
 
   /**
@@ skipping 148 matching lines @@
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created prefixed identifier.
    *
    * @param prefix the identifier being prefixed
    * @param period the period used to separate the prefix from the identifier
    * @param identifier the prefix associated with the library in which the identifier is defined
    */
-  PrefixedIdentifier(SimpleIdentifier prefix, this.period, SimpleIdentifier identifier) {
+  PrefixedIdentifier(SimpleIdentifier prefix, Token period, SimpleIdentifier identifier) {
     this._prefix = becomeParentOf(prefix);
+    this.period = period;
     this._identifier = becomeParentOf(identifier);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPrefixedIdentifier(this);
 
   @override
   Token get beginToken => _prefix.beginToken;
 
   @override
@@ skipping 97 matching lines @@
    */
   SimpleIdentifier _propertyName;
 
   /**
    * Initialize a newly created property access expression.
    *
    * @param target the expression computing the object defining the property being accessed
    * @param operator the property access operator
    * @param propertyName the name of the property being accessed
    */
-  PropertyAccess(Expression target, this.operator, SimpleIdentifier propertyName) {
+  PropertyAccess(Expression target, Token operator, SimpleIdentifier propertyName) {
     this._target = becomeParentOf(target);
+    this.operator = operator;
     this._propertyName = becomeParentOf(propertyName);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitPropertyAccess(this);
 
   @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
@@ skipping 124 matching lines @@
 
   /**
    * Initialize a newly created redirecting invocation to invoke the constructor with the given name
    * with the given arguments.
    *
    * @param keyword the token for the 'this' keyword
    * @param period the token for the period before the name of the constructor that is being invoked
    * @param constructorName the name of the constructor that is being invoked
    * @param argumentList the list of arguments to the constructor
    */
-  RedirectingConstructorInvocation(this.keyword, this.period, SimpleIdentifier constructorName, ArgumentList argumentList) {
+  RedirectingConstructorInvocation(Token keyword, Token period, SimpleIdentifier constructorName, ArgumentList argumentList) {
+    this.keyword = keyword;
+    this.period = period;
     this._constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitRedirectingConstructorInvocation(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
@@ skipping 52 matching lines @@
   /**
    * The token representing the 'rethrow' keyword.
    */
   Token keyword;
 
   /**
    * Initialize a newly created rethrow expression.
    *
    * @param keyword the token representing the 'rethrow' keyword
    */
-  RethrowExpression(this.keyword);
+  RethrowExpression(Token keyword) {
+    this.keyword = keyword;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitRethrowExpression(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => keyword;
 
@@ skipping 30 matching lines @@
    */
   Token semicolon;
 
   /**
    * Initialize a newly created return statement.
    *
    * @param keyword the token representing the 'return' keyword
    * @param expression the expression computing the value to be returned
    * @param semicolon the semicolon terminating the statement
    */
-  ReturnStatement(this.keyword, Expression expression, this.semicolon) {
+  ReturnStatement(Token keyword, Expression expression, Token semicolon) {
+    this.keyword = keyword;
     this._expression = becomeParentOf(expression);
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitReturnStatement(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => semicolon;
@@ skipping 34 matching lines @@
   /**
    * The token representing this script tag.
    */
   Token scriptTag;
 
   /**
    * Initialize a newly created script tag.
    *
    * @param scriptTag the token representing this script tag
    */
-  ScriptTag(this.scriptTag);
+  ScriptTag(Token scriptTag) {
+    this.scriptTag = scriptTag;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitScriptTag(this);
 
   @override
   Token get beginToken => scriptTag;
 
   @override
   Token get endToken => scriptTag;
 
@@ skipping 70 matching lines @@
 
   /**
    * Initialize a newly created formal parameter.
    *
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    * @param type the name of the declared type of the parameter
    * @param identifier the name of the parameter being declared
    */
-  SimpleFormalParameter(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, SimpleIdentifier identifier) : super(comment, metadata, identifier) {
+  SimpleFormalParameter(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, SimpleIdentifier identifier) : super(comment, metadata, identifier) {
+    this.keyword = keyword;
     this._type = becomeParentOf(type);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSimpleFormalParameter(this);
 
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
@@ skipping 73 matching lines @@
    * be set to hold onto the static and propagated information. The auxiliary element will hold onto
    * the elements from the getter context.
    */
   AuxiliaryElements auxiliaryElements = null;
 
   /**
    * Initialize a newly created identifier.
    *
    * @param token the token representing the identifier
    */
-  SimpleIdentifier(this.token);
+  SimpleIdentifier(Token token) {
+    this.token = token;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSimpleIdentifier(this);
 
   @override
   Token get beginToken => token;
 
   @override
   Element get bestElement {
     if (_propagatedElement == null) {
@@ skipping 254 matching lines @@
    * The toolkit specific element associated with this literal, or `null`.
    */
   Element _toolkitElement;
 
   /**
    * Initialize a newly created simple string literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
-  SimpleStringLiteral(this.literal, String value) {
+  SimpleStringLiteral(Token literal, String value) {
+    this.literal = literal;
     this._value = StringUtilities.intern(value);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSimpleStringLiteral(this);
 
   @override
   Token get beginToken => literal;
 
   @override
@@ skipping 236 matching lines @@
 
   /**
    * Initialize a newly created super invocation to invoke the inherited constructor with the given
    * name with the given arguments.
    *
    * @param keyword the token for the 'super' keyword
    * @param period the token for the period before the name of the constructor that is being invoked
    * @param constructorName the name of the constructor that is being invoked
    * @param argumentList the list of arguments to the constructor
    */
-  SuperConstructorInvocation(this.keyword, this.period, SimpleIdentifier constructorName, ArgumentList argumentList) {
+  SuperConstructorInvocation(Token keyword, Token period, SimpleIdentifier constructorName, ArgumentList argumentList) {
+    this.keyword = keyword;
+    this.period = period;
     this._constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSuperConstructorInvocation(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
@@ skipping 52 matching lines @@
   /**
    * The token representing the keyword.
    */
   Token keyword;
 
   /**
    * Initialize a newly created super expression.
    *
    * @param keyword the token representing the keyword
    */
-  SuperExpression(this.keyword);
+  SuperExpression(Token keyword) {
+    this.keyword = keyword;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSuperExpression(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => keyword;
 
@@ skipping 120 matching lines @@
   NodeList<Statement> _statements;
 
   /**
    * Initialize a newly created switch member.
    *
    * @param labels the labels associated with the switch member
    * @param keyword the token representing the 'case' or 'default' keyword
    * @param colon the colon separating the keyword or the expression from the statements
    * @param statements the statements that will be executed if this switch member is selected
    */
-  SwitchMember(List<Label> labels, this.keyword, this.colon, List<Statement> statements) {
+  SwitchMember(List<Label> labels, Token keyword, Token colon, List<Statement> statements) {
     this._labels = new NodeList<Label>(this);
     this._statements = new NodeList<Statement>(this);
     this._labels.addAll(labels);
+    this.keyword = keyword;
+    this.colon = colon;
     this._statements.addAll(statements);
   }
 
   @override
   Token get beginToken {
     if (!_labels.isEmpty) {
       return _labels.beginToken;
     }
     return keyword;
   }
@@ skipping 69 matching lines @@
    * Initialize a newly created switch statement.
    *
    * @param keyword the token representing the 'switch' keyword
    * @param leftParenthesis the left parenthesis
    * @param expression the expression used to determine which of the switch members will be selected
    * @param rightParenthesis the right parenthesis
    * @param leftBracket the left curly bracket
    * @param members the switch members that can be selected by the expression
    * @param rightBracket the right curly bracket
    */
-  SwitchStatement(this.keyword, this.leftParenthesis, Expression expression, this.rightParenthesis, this.leftBracket, List<SwitchMember> members, this.rightBracket) {
+  SwitchStatement(Token keyword, Token leftParenthesis, Expression expression, Token rightParenthesis, Token leftBracket, List<SwitchMember> members, Token rightBracket) {
     this._members = new NodeList<SwitchMember>(this);
+    this.keyword = keyword;
+    this.leftParenthesis = leftParenthesis;
     this._expression = becomeParentOf(expression);
+    this.rightParenthesis = rightParenthesis;
+    this.leftBracket = leftBracket;
     this._members.addAll(members);
+    this.rightBracket = rightBracket;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSwitchStatement(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => rightBracket;
@@ skipping 39 matching lines @@
  */
 class SymbolLiteral extends Literal {
   /**
    * The token introducing the literal.
    */
   Token poundSign;
 
   /**
    * The components of the literal.
    */
-  final List<Token> components;
+  List<Token> components;
 
   /**
    * Initialize a newly created symbol literal.
    *
    * @param poundSign the token introducing the literal
    * @param components the components of the literal
    */
-  SymbolLiteral(this.poundSign, this.components);
+  SymbolLiteral(Token poundSign, List<Token> components) {
+    this.poundSign = poundSign;
+    this.components = components;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitSymbolLiteral(this);
 
   @override
   Token get beginToken => poundSign;
 
   @override
   Token get endToken => components[components.length - 1];
 
@@ skipping 14 matching lines @@
   /**
    * The token representing the keyword.
    */
   Token keyword;
 
   /**
    * Initialize a newly created this expression.
    *
    * @param keyword the token representing the keyword
    */
-  ThisExpression(this.keyword);
+  ThisExpression(Token keyword) {
+    this.keyword = keyword;
+  }
 
   @override
   accept(AstVisitor visitor) => visitor.visitThisExpression(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
   Token get endToken => keyword;
 
@@ skipping 23 matching lines @@
    * The expression computing the exception to be thrown.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created throw expression.
    *
    * @param keyword the token representing the 'throw' keyword
    * @param expression the expression computing the exception to be thrown
    */
-  ThrowExpression(this.keyword, Expression expression) {
+  ThrowExpression(Token keyword, Expression expression) {
+    this.keyword = keyword;
     this._expression = becomeParentOf(expression);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitThrowExpression(this);
 
   @override
   Token get beginToken => keyword;
 
   @override
@@ skipping 51 matching lines @@
   Token semicolon;
 
   /**
    * Initialize a newly created top-level variable declaration.
    *
    * @param comment the documentation comment associated with this variable
    * @param metadata the annotations associated with this variable
    * @param variableList the top-level variables being declared
    * @param semicolon the semicolon terminating the declaration
    */
-  TopLevelVariableDeclaration(Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, this.semicolon) : super(comment, metadata) {
+  TopLevelVariableDeclaration(Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, Token semicolon) : super(comment, metadata) {
     this._variableList = becomeParentOf(variableList);
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTopLevelVariableDeclaration(this);
 
   @override
   Element get element => null;
 
   @override
   Token get endToken => semicolon;
@@ skipping 65 matching lines @@
 
   /**
    * Initialize a newly created try statement.
    *
    * @param tryKeyword the token representing the 'try' keyword
    * @param body the body of the statement
    * @param catchClauses the catch clauses contained in the try statement
    * @param finallyKeyword the token representing the 'finally' keyword
    * @param finallyBlock the finally block contained in the try statement
    */
-  TryStatement(this.tryKeyword, Block body, List<CatchClause> catchClauses, this.finallyKeyword, Block finallyBlock) {
+  TryStatement(Token tryKeyword, Block body, List<CatchClause> catchClauses, Token finallyKeyword, Block finallyBlock) {
     this._catchClauses = new NodeList<CatchClause>(this);
+    this.tryKeyword = tryKeyword;
     this._body = becomeParentOf(body);
     this._catchClauses.addAll(catchClauses);
+    this.finallyKeyword = finallyKeyword;
     this._finallyBlock = becomeParentOf(finallyBlock);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTryStatement(this);
 
   @override
   Token get beginToken => tryKeyword;
 
   /**
@@ skipping 80 matching lines @@
   Token semicolon;
 
   /**
    * Initialize a newly created type alias.
    *
    * @param comment the documentation comment associated with this type alias
    * @param metadata the annotations associated with this type alias
    * @param keyword the token representing the 'typedef' keyword
    * @param semicolon the semicolon terminating the declaration
    */
-  TypeAlias(Comment comment, List<Annotation> metadata, this.keyword, this.semicolon) : super(comment, metadata);
+  TypeAlias(Comment comment, List<Annotation> metadata, Token keyword, Token semicolon) : super(comment, metadata) {
+    this.keyword = keyword;
+    this.semicolon = semicolon;
+  }
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => keyword;
 }
 
 /**
  * Instances of the class `TypeArgumentList` represent a list of type arguments.
@@ skipping 19 matching lines @@
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created list of type arguments.
    *
    * @param leftBracket the left bracket
    * @param arguments the type arguments associated with the type
    * @param rightBracket the right bracket
    */
-  TypeArgumentList(this.leftBracket, List<TypeName> arguments, this.rightBracket) {
+  TypeArgumentList(Token leftBracket, List<TypeName> arguments, Token rightBracket) {
     this._arguments = new NodeList<TypeName>(this);
+    this.leftBracket = leftBracket;
     this._arguments.addAll(arguments);
+    this.rightBracket = rightBracket;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTypeArgumentList(this);
 
   /**
    * Return the type arguments associated with the type.
    *
    * @return the type arguments associated with the type
    */
@@ skipping 133 matching lines @@
 
   /**
    * Initialize a newly created type parameter.
    *
    * @param comment the documentation comment associated with the type parameter
    * @param metadata the annotations associated with the type parameter
    * @param name the name of the type parameter
    * @param keyword the token representing the 'extends' keyword
    * @param bound the name of the upper bound for legal arguments
    */
-  TypeParameter(Comment comment, List<Annotation> metadata, SimpleIdentifier name, this.keyword, TypeName bound) : super(comment, metadata) {
+  TypeParameter(Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token keyword, TypeName bound) : super(comment, metadata) {
     this._name = becomeParentOf(name);
+    this.keyword = keyword;
     this._bound = becomeParentOf(bound);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTypeParameter(this);
 
   /**
    * Return the name of the upper bound for legal arguments, or `null` if there was no
    * explicit upper bound.
    *
@@ skipping 53 matching lines @@
  *
  * <pre>
  * typeParameterList ::=
  *     '<' [TypeParameter] (',' [TypeParameter])* '>'
  * </pre>
  */
 class TypeParameterList extends AstNode {
   /**
    * The left angle bracket.
    */
-  final Token leftBracket;
+  Token leftBracket;
 
   /**
    * The type parameters in the list.
    */
   NodeList<TypeParameter> _typeParameters;
 
   /**
    * The right angle bracket.
    */
-  final Token rightBracket;
+  Token rightBracket;
 
   /**
    * Initialize a newly created list of type parameters.
    *
    * @param leftBracket the left angle bracket
    * @param typeParameters the type parameters in the list
    * @param rightBracket the right angle bracket
    */
-  TypeParameterList(this.leftBracket, List<TypeParameter> typeParameters, this.rightBracket) {
+  TypeParameterList(Token leftBracket, List<TypeParameter> typeParameters, Token rightBracket) {
     this._typeParameters = new NodeList<TypeParameter>(this);
+    this.leftBracket = leftBracket;
     this._typeParameters.addAll(typeParameters);
+    this.rightBracket = rightBracket;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitTypeParameterList(this);
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Token get endToken => rightBracket;
@@ skipping 33 matching lines @@
    */
   TypeArgumentList typeArguments;
 
   /**
    * Initialize a newly created typed literal.
    *
    * @param constKeyword the token representing the 'const' keyword
    * @param typeArguments the type argument associated with this literal, or `null` if no type
    *          arguments were declared
    */
-  TypedLiteral(this.constKeyword, TypeArgumentList typeArguments) {
+  TypedLiteral(Token constKeyword, TypeArgumentList typeArguments) {
+    this.constKeyword = constKeyword;
     this.typeArguments = becomeParentOf(typeArguments);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(typeArguments, visitor);
   }
 }
 
 /**
@@ skipping 96 matching lines @@
 
   /**
    * Initialize a newly created variable declaration.
    *
    * @param comment the documentation comment associated with this declaration
    * @param metadata the annotations associated with this member
    * @param name the name of the variable being declared
    * @param equals the equal sign separating the variable name from the initial value
    * @param initializer the expression used to compute the initial value for the variable
    */
-  VariableDeclaration(Comment comment, List<Annotation> metadata, SimpleIdentifier name, this.equals, Expression initializer) : super(comment, metadata) {
+  VariableDeclaration(Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token equals, Expression initializer) : super(comment, metadata) {
     this._name = becomeParentOf(name);
+    this.equals = equals;
     this._initializer = becomeParentOf(initializer);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitVariableDeclaration(this);
 
   /**
    * This overridden implementation of getDocumentationComment() looks in the grandparent node for
    * dartdoc comments if no documentation is specifically available on the node.
    */
@@ skipping 122 matching lines @@
 
   /**
    * Initialize a newly created variable declaration list.
    *
    * @param comment the documentation comment associated with this declaration list
    * @param metadata the annotations associated with this declaration list
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    * @param type the type of the variables being declared
    * @param variables a list containing the individual variables being declared
    */
-  VariableDeclarationList(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, List<VariableDeclaration> variables) : super(comment, metadata) {
+  VariableDeclarationList(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, List<VariableDeclaration> variables) : super(comment, metadata) {
     this._variables = new NodeList<VariableDeclaration>(this);
+    this.keyword = keyword;
     this._type = becomeParentOf(type);
     this._variables.addAll(variables);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitVariableDeclarationList(this);
 
   @override
   Token get endToken => _variables.endToken;
 
@@ skipping 72 matching lines @@
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created variable declaration statement.
    *
    * @param variableList the fields being declared
    * @param semicolon the semicolon terminating the statement
    */
-  VariableDeclarationStatement(VariableDeclarationList variableList, this.semicolon) {
+  VariableDeclarationStatement(VariableDeclarationList variableList, Token semicolon) {
     this._variableList = becomeParentOf(variableList);
+    this.semicolon = semicolon;
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitVariableDeclarationStatement(this);
 
   @override
   Token get beginToken => _variableList.beginToken;
 
   @override
   Token get endToken => semicolon;
@@ skipping 56 matching lines @@
 
   /**
    * Initialize a newly created while statement.
    *
    * @param keyword the token representing the 'while' keyword
    * @param leftParenthesis the left parenthesis
    * @param condition the expression used to determine whether to execute the body of the loop
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
-  WhileStatement(this.keyword, this.leftParenthesis, Expression condition, this.rightParenthesis, Statement body) {
+  WhileStatement(Token keyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Statement body) {
+    this.keyword = keyword;
+    this.leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
+    this.rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitWhileStatement(this);
 
   @override
   Token get beginToken => keyword;
 
   /**
@@ skipping 2116 matching lines @@
 }
 
 /**
  * Instances of the class `ToSourceVisitor` write a source representation of a visited AST
  * node (and all of it's children) to a writer.
  */
 class ToSourceVisitor implements AstVisitor<Object> {
   /**
    * The writer to which the source is to be written.
    */
-  final PrintWriter _writer;
+  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(this._writer);
+  ToSourceVisitor(PrintWriter writer) {
+    this._writer = writer;
+  }
 
   @override
   Object visitAdjacentStrings(AdjacentStrings node) {
     _visitNodeListWithSeparator(node.strings, " ");
     return null;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     _writer.print('@');
@@ skipping 2481 matching lines @@
 /**
  * Instances of the class `IncrementalAstCloner` implement an object that will clone any AST
  * structure that it visits. The cloner will clone the structure, replacing the specified ASTNode
  * with a new ASTNode, mapping the old token stream to a new token stream, and preserving resolution
  * results.
  */
 class IncrementalAstCloner implements AstVisitor<AstNode> {
   /**
    * The node to be replaced during the cloning process.
    */
-  final AstNode _oldNode;
+  AstNode _oldNode;
 
   /**
    * The replacement node used during the cloning process.
    */
-  final AstNode _newNode;
+  AstNode _newNode;
 
   /**
    * A mapping of old tokens to new tokens used during the cloning process.
    */
-  final TokenMap _tokenMap;
+  TokenMap _tokenMap;
 
   /**
    * Construct a new instance that will replace `oldNode` with `newNode` in the process
    * of cloning an existing AST structure.
    *
    * @param oldNode the node to be replaced
    * @param newNode the replacement node
    * @param tokenMap a mapping of old tokens to new tokens (not `null`)
    */
-  IncrementalAstCloner(this._oldNode, this._newNode, this._tokenMap);
+  IncrementalAstCloner(AstNode oldNode, AstNode newNode, TokenMap tokenMap) {
+    this._oldNode = oldNode;
+    this._newNode = newNode;
+    this._tokenMap = tokenMap;
+  }
 
   @override
   AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings(_cloneNodeList(node.strings));
 
   @override
   Annotation visitAnnotation(Annotation node) {
     Annotation copy = new Annotation(_mapToken(node.atSign), _cloneNode(node.name), _mapToken(node.period), _cloneNode(node.constructorName), _cloneNode(node.arguments));
     copy.element = node.element;
     return copy;
   }
@@ skipping 594 matching lines @@
  * Completion test code coverage is 95%. The two basic blocks that are not executed cannot be
  * executed. They are included for future reference.
  */
 class ScopedNameFinder extends GeneralizingAstVisitor<Object> {
   Declaration _declarationNode;
 
   AstNode _immediateChild;
 
   Map<String, SimpleIdentifier> _locals = new Map<String, SimpleIdentifier>();
 
-  final int _position;
+  int _position = 0;
 
   bool _referenceIsWithinLocalFunction = false;
 
-  ScopedNameFinder(this._position);
+  ScopedNameFinder(int position) {
+    this._position = position;
+  }
 
   Declaration get declaration => _declarationNode;
 
   Map<String, SimpleIdentifier> get locals => _locals;
 
   @override
   Object visitBlock(Block node) {
     _checkStatements(node.statements);
     return super.visitBlock(node);
   }
@@ skipping 265 matching lines @@
     _elements[index] = node;
   }
   void clear() {
     _elements = <E> [];
   }
   int get length => _elements.length;
   void set length(int value) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 }