New analyzer snapshot.

pkg/analyzer/lib/src/generated/ast.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.ast;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart' show LineInfo;
 import 'scanner.dart';
@@ skipping 467 matching lines @@
  * adjacentStrings ::=
  *     [StringLiteral] [StringLiteral]+
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class AdjacentStrings extends StringLiteral {
   /**
    * The strings that are implicitly concatenated.
    */
-  NodeList<StringLiteral> strings;
+  NodeList<StringLiteral> _strings;
 
   /**
    * Initialize a newly created list of adjacent strings.
    *
    * @param strings the strings that are implicitly concatenated
    */
   AdjacentStrings.full(List<StringLiteral> strings) {
-    this.strings = new NodeList<StringLiteral>(this);
-    this.strings.addAll(strings);
+    this._strings = new NodeList<StringLiteral>(this);
+    this._strings.addAll(strings);
   }
 
   /**
    * Initialize a newly created list of adjacent strings.
    *
    * @param strings the strings that are implicitly concatenated
    */
   AdjacentStrings({List<StringLiteral> strings}) : this.full(strings);

[Brian Wilkerson, 2013/12/10 14:57:41]

I never noticed this before, but why are we generating a constructor with an
optional argument when the original source doesn't include a zero-argument
constructor?

[scheglov, 2013/12/10 18:21:09]

At one point I thought that it is nice to provide a constructor with optional
named parameters.
But yes, this may promote making errors, such as NPEs.
Removed.

 
   accept(ASTVisitor visitor) => visitor.visitAdjacentStrings(this);
 
-  Token get beginToken => strings.beginToken;
+  Token get beginToken => _strings.beginToken;
 
-  Token get endToken => strings.endToken;
+  Token get endToken => _strings.endToken;
+
+  /**
+   * Return the strings that are implicitly concatenated.
+   *
+   * @return the strings that are implicitly concatenated
+   */
+  NodeList<StringLiteral> get strings => _strings;

[Brian Wilkerson, 2013/12/10 14:57:41]

Does this mean that what we were generating before is wrong, or is this a
regression?

[scheglov, 2013/12/10 18:21:09]

It was generated wrongly before.

In Java property "strings" is read-only, so to keep it just a field we would
need to mark it final.
However its initializer references "this", which is fine in Java, but not in
Dart.
So, we have to move the initializer into the constructor body and make property
read-only by providing only getter.

 
   void visitChildren(ASTVisitor visitor) {
-    strings.accept(visitor);
+    _strings.accept(visitor);
   }
 
   void appendStringValue(JavaStringBuilder builder) {
     for (StringLiteral stringLiteral in strings) {
       stringLiteral.appendStringValue(builder);
     }
   }
 }
 
 /**
@@ skipping 190 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.full(Token atSign, Identifier name, Token period, SimpleIdentifier constructorName, ArgumentList arguments) {
-    this.atSign = atSign;
+  Annotation.full(this.atSign, Identifier name, this.period, SimpleIdentifier constructorName, ArgumentList arguments) {
     this._name = becomeParentOf(name);
-    this.period = period;
     this._constructorName = becomeParentOf(constructorName);
     this._arguments = becomeParentOf(arguments);
   }
 
   /**
    * Initialize a newly created annotation.
    *
    * @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
@@ skipping 123 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.full(Token question, SimpleIdentifier identifier) {
-    this.question = question;
+  ArgumentDefinitionTest.full(this.question, SimpleIdentifier identifier) {
     this._identifier = becomeParentOf(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({Token question, SimpleIdentifier identifier}) : this.full(question, identifier);
@@ skipping 44 matching lines @@
  */
 class ArgumentList extends ASTNode {
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
   /**
    * The expressions producing the values of the arguments.
    */
-  NodeList<Expression> arguments;
+  NodeList<Expression> _arguments;
 
   /**
    * The right parenthesis.
    */
   Token _rightParenthesis;
 
   /**
    * An array containing the elements representing the parameters corresponding to each of the
    * arguments in this list, or `null` if the AST has not been resolved or if the function or
    * method being invoked could not be determined based on static type information. The array must
@@ skipping 12 matching lines @@
   List<ParameterElement> _correspondingPropagatedParameters;
 
   /**
    * Initialize a newly created list of arguments.
    *
    * @param leftParenthesis the left parenthesis
    * @param arguments the expressions producing the values of the arguments
    * @param rightParenthesis the right parenthesis
    */
   ArgumentList.full(Token leftParenthesis, List<Expression> arguments, Token rightParenthesis) {
-    this.arguments = new NodeList<Expression>(this);
+    this._arguments = new NodeList<Expression>(this);
     this._leftParenthesis = leftParenthesis;
-    this.arguments.addAll(arguments);
+    this._arguments.addAll(arguments);
     this._rightParenthesis = rightParenthesis;
   }
 
   /**
    * Initialize a newly created list of arguments.
    *
    * @param leftParenthesis the left parenthesis
    * @param arguments the expressions producing the values of the arguments
    * @param rightParenthesis the right parenthesis
    */
   ArgumentList({Token leftParenthesis, List<Expression> arguments, Token rightParenthesis}) : this.full(leftParenthesis, arguments, rightParenthesis);
 
   accept(ASTVisitor visitor) => visitor.visitArgumentList(this);
 
+  /**
+   * Return the expressions producing the values of the arguments. Although the language requires
+   * that positional arguments appear before named arguments, this class allows them to be
+   * intermixed.
+   *
+   * @return the expressions producing the values of the arguments
+   */
+  NodeList<Expression> get arguments => _arguments;
+
   Token get beginToken => _leftParenthesis;
 
   Token get endToken => _rightParenthesis;
 
   /**
    * Return the left parenthesis.
    *
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
 
   /**
    * Return the right parenthesis.
    *
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
 
   /**
    * Set the parameter elements corresponding to each of the arguments in this list to the given
    * array of parameters. The array of parameters must be the same length as the number of
    * arguments, but can contain `null` entries if a given argument does not correspond to a
    * formal parameter.
    *
    * @param parameters the parameter elements corresponding to the arguments
    */
   void set correspondingPropagatedParameters(List<ParameterElement> parameters) {
-    if (parameters.length != arguments.length) {
-      throw new IllegalArgumentException("Expected ${arguments.length} parameters, not ${parameters.length}");
+    if (parameters.length != _arguments.length) {
+      throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
     }
     _correspondingPropagatedParameters = parameters;
   }
 
   /**
    * Set the parameter elements corresponding to each of the arguments in this list to the given
    * array of parameters. The array of parameters must be the same length as the number of
    * arguments, but can contain `null` entries if a given argument does not correspond to a
    * formal parameter.
    *
    * @param parameters the parameter elements corresponding to the arguments
    */
   void set correspondingStaticParameters(List<ParameterElement> parameters) {
-    if (parameters.length != arguments.length) {
-      throw new IllegalArgumentException("Expected ${arguments.length} parameters, not ${parameters.length}");
+    if (parameters.length != _arguments.length) {
+      throw new IllegalArgumentException("Expected ${_arguments.length} parameters, not ${parameters.length}");
     }
     _correspondingStaticParameters = parameters;
   }
 
   /**
    * Set the left parenthesis to the given token.
    *
    * @param parenthesis the left parenthesis
    */
   void set leftParenthesis(Token parenthesis) {
     _leftParenthesis = parenthesis;
   }
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
 
   void visitChildren(ASTVisitor visitor) {
-    arguments.accept(visitor);
+    _arguments.accept(visitor);
   }
 
   /**
    * If the given expression is a child of this list, and the AST structure has been resolved, and
    * the function being invoked is known based on propagated type information, and the expression
    * corresponds to one of the parameters of the function being invoked, then return the parameter
    * element representing the parameter to which the value of the given expression will be bound.
    * Otherwise, return `null`.
    *
    * This method is only intended to be used by [Expression#getPropagatedParameterElement].
    *
    * @param expression the expression corresponding to the parameter to be returned
    * @return the parameter element representing the parameter to which the value of the expression
    *         will be bound
    */
   ParameterElement getPropagatedParameterElementFor(Expression expression) {
     if (_correspondingPropagatedParameters == null) {
       return null;
     }
-    int index = arguments.indexOf(expression);
+    int index = _arguments.indexOf(expression);
     if (index < 0) {
       return null;
     }
     return _correspondingPropagatedParameters[index];
   }
 
   /**
    * If the given expression is a child of this list, and the AST structure has been resolved, and
    * the function being invoked is known based on static type information, and the expression
    * corresponds to one of the parameters of the function being invoked, then return the parameter
    * element representing the parameter to which the value of the given expression will be bound.
    * Otherwise, return `null`.
    *
    * This method is only intended to be used by [Expression#getStaticParameterElement].
    *
    * @param expression the expression corresponding to the parameter to be returned
    * @return the parameter element representing the parameter to which the value of the expression
    *         will be bound
    */
   ParameterElement getStaticParameterElementFor(Expression expression) {
     if (_correspondingStaticParameters == null) {
       return null;
     }
-    int index = arguments.indexOf(expression);
+    int index = _arguments.indexOf(expression);
     if (index < 0) {
       return null;
     }
     return _correspondingStaticParameters[index];
   }
 }
 
 /**
  * Instances of the class `AsExpression` represent an 'as' expression.
  *
@@ skipping 126 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.full(Token keyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon) {
-    this.keyword = keyword;
-    this.leftParenthesis = leftParenthesis;
+  AssertStatement.full(this.keyword, this.leftParenthesis, Expression condition, this.rightParenthesis, this.semicolon) {
     this._condition = becomeParentOf(condition);
-    this.rightParenthesis = rightParenthesis;
-    this.semicolon = semicolon;
   }
 
   /**
    * 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
@@ skipping 67 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.full(Expression leftHandSide, Token operator, Expression rightHandSide) {
+  AssignmentExpression.full(Expression leftHandSide, this.operator, Expression rightHandSide) {
     this._leftHandSide = becomeParentOf(leftHandSide);
-    this.operator = operator;
     this._rightHandSide = becomeParentOf(rightHandSide);
   }
 
   /**
    * 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
    */
@@ skipping 183 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.full(Expression leftOperand, Token operator, Expression rightOperand) {
+  BinaryExpression.full(Expression leftOperand, this.operator, Expression rightOperand) {
     this._leftOperand = becomeParentOf(leftOperand);
-    this.operator = operator;
     this._rightOperand = becomeParentOf(rightOperand);
   }
 
   /**
    * 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
    */
@@ skipping 155 matching lines @@
  */
 class Block extends Statement {
   /**
    * The left curly bracket.
    */
   Token leftBracket;
 
   /**
    * The statements contained in the block.
    */
-  NodeList<Statement> statements;
+  NodeList<Statement> _statements;
 
   /**
    * The right curly bracket.
    */
   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.full(Token leftBracket, List<Statement> statements, Token rightBracket) {
-    this.statements = new NodeList<Statement>(this);
-    this.leftBracket = leftBracket;
-    this.statements.addAll(statements);
-    this.rightBracket = rightBracket;
+  Block.full(this.leftBracket, List<Statement> statements, this.rightBracket) {
+    this._statements = new NodeList<Statement>(this);
+    this._statements.addAll(statements);
   }
 
   /**
    * 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({Token leftBracket, List<Statement> statements, Token rightBracket}) : this.full(leftBracket, statements, rightBracket);
 
   accept(ASTVisitor visitor) => visitor.visitBlock(this);
 
   Token get beginToken => leftBracket;
 
   Token get endToken => rightBracket;
 
+  /**
+   * Return the statements contained in the block.
+   *
+   * @return the statements contained in the block
+   */
+  NodeList<Statement> get statements => _statements;
+
   void visitChildren(ASTVisitor visitor) {
-    statements.accept(visitor);
+    _statements.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `BlockFunctionBody` represent a function body that consists of a
  * block of statements.
  *
  * <pre>
  * blockFunctionBody ::=
  *     [Block]
@@ skipping 70 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.full(Token literal, bool value) {
-    this.literal = literal;
-    this.value = value;
-  }
+  BooleanLiteral.full(this.literal, this.value);
 
   /**
    * Initialize a newly created boolean literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   BooleanLiteral({Token literal, bool value}) : this.full(literal, value);
 
   accept(ASTVisitor visitor) => visitor.visitBooleanLiteral(this);
@@ skipping 34 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.full(Token keyword, SimpleIdentifier label, Token semicolon) {
-    this.keyword = keyword;
+  BreakStatement.full(this.keyword, SimpleIdentifier label, this.semicolon) {
     this._label = becomeParentOf(label);
-    this.semicolon = 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({Token keyword, SimpleIdentifier label, Token semicolon}) : this.full(keyword, label, semicolon);
@@ skipping 47 matching lines @@
  */
 class CascadeExpression extends Expression {
   /**
    * The target of the cascade sections.
    */
   Expression _target;
 
   /**
    * The cascade sections sharing the common target.
    */
-  NodeList<Expression> cascadeSections;
+  NodeList<Expression> _cascadeSections;
 
   /**
    * Initialize a newly created cascade expression.
    *
    * @param target the target of the cascade sections
    * @param cascadeSections the cascade sections sharing the common target
    */
   CascadeExpression.full(Expression target, List<Expression> cascadeSections) {
-    this.cascadeSections = new NodeList<Expression>(this);
+    this._cascadeSections = new NodeList<Expression>(this);
     this._target = becomeParentOf(target);
-    this.cascadeSections.addAll(cascadeSections);
+    this._cascadeSections.addAll(cascadeSections);
   }
 
   /**
    * Initialize a newly created cascade expression.
    *
    * @param target the target of the cascade sections
    * @param cascadeSections the cascade sections sharing the common target
    */
   CascadeExpression({Expression target, List<Expression> cascadeSections}) : this.full(target, cascadeSections);
 
   accept(ASTVisitor visitor) => visitor.visitCascadeExpression(this);
 
   Token get beginToken => _target.beginToken;
 
-  Token get endToken => cascadeSections.endToken;
+  /**
+   * Return the cascade sections sharing the common target.
+   *
+   * @return the cascade sections sharing the common target
+   */
+  NodeList<Expression> get cascadeSections => _cascadeSections;
+
+  Token get endToken => _cascadeSections.endToken;
 
   int get precedence => 2;
 
   /**
    * Return the target of the cascade sections.
    *
    * @return the target of the cascade sections
    */
   Expression get target => _target;
 
   /**
    * Set the target of the cascade sections to the given expression.
    *
    * @param target the target of the cascade sections
    */
   void set target(Expression target) {
     this._target = becomeParentOf(target);
   }
 
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_target, visitor);
-    cascadeSections.accept(visitor);
+    _cascadeSections.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `CatchClause` represent a catch clause within a try statement.
  *
  * <pre>
  * onPart ::=
  *     catchPart [Block]
  *   | 'on' type catchPart? [Block]
@@ skipping 59 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.full(Token onKeyword, TypeName exceptionType, Token catchKeyword, Token leftParenthesis, SimpleIdentifier exceptionParameter, Token comma, SimpleIdentifier stackTraceParameter, Token rightParenthesis, Block body) {
-    this.onKeyword = onKeyword;
+  CatchClause.full(this.onKeyword, TypeName exceptionType, this.catchKeyword, Token leftParenthesis, SimpleIdentifier exceptionParameter, this.comma, SimpleIdentifier stackTraceParameter, Token rightParenthesis, Block body) {
     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);
   }
 
   /**
    * Initialize a newly created catch clause.
    *
    * @param onKeyword the token representing the 'on' keyword
    * @param exceptionType the type of exceptions caught by this catch clause
@@ skipping 166 matching lines @@
   NativeClause nativeClause;
 
   /**
    * The left curly bracket.
    */
   Token leftBracket;
 
   /**
    * The members defined by the class.
    */
-  NodeList<ClassMember> members;
+  NodeList<ClassMember> _members;
 
   /**
    * The right curly bracket.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created class declaration.
    *
    * @param comment the documentation comment associated with this class
    * @param metadata the annotations associated with this class
    * @param abstractKeyword the 'abstract' keyword, or `null` if the keyword was absent
    * @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.full(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.full(comment, metadata) {
-    this.members = new NodeList<ClassMember>(this);
-    this.abstractKeyword = abstractKeyword;
-    this.classKeyword = classKeyword;
+  ClassDeclaration.full(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.full(comment, metadata) {
+    this._members = new NodeList<ClassMember>(this);
     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;
+    this._members.addAll(members);
   }
 
   /**
    * Initialize a newly created class declaration.
    *
    * @param comment the documentation comment associated with this class
    * @param metadata the annotations associated with this class
    * @param abstractKeyword the 'abstract' keyword, or `null` if the keyword was absent
    * @param classKeyword the token representing the 'class' keyword
    * @param name the name of the class being declared
@@ skipping 23 matching lines @@
 
   /**
    * Return the implements clause for the class, or `null` if the class does not implement any
    * interfaces.
    *
    * @return the implements clause for the class
    */
   ImplementsClause get implementsClause => _implementsClause;
 
   /**
+   * Return the members defined by the class.
+   *
+   * @return the members defined by the class
+   */
+  NodeList<ClassMember> get members => _members;
+
+  /**
    * Return the name of the class being declared.
    *
    * @return the name of the class being declared
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Return the with clause for the class, or `null` if the class does not have a with clause.
    *
    * @return the with clause for the class
@@ skipping 138 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.full(Comment comment, List<Annotation> metadata, Token keyword, SimpleIdentifier name, TypeParameterList typeParameters, Token equals, Token abstractKeyword, TypeName superclass, WithClause withClause, ImplementsClause implementsClause, Token semicolon) : super.full(comment, metadata, keyword, semicolon) {
+  ClassTypeAlias.full(Comment comment, List<Annotation> metadata, Token keyword, SimpleIdentifier name, TypeParameterList typeParameters, this.equals, this.abstractKeyword, TypeName superclass, WithClause withClause, ImplementsClause implementsClause, Token semicolon) : super.full(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);
   }
 
   /**
    * Initialize a newly created class type alias.
    *
    * @param comment the documentation comment associated with this type alias
    * @param metadata the annotations associated with this type alias
@@ skipping 121 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.full(Token keyword) {
-    this.keyword = keyword;
-  }
+  Combinator.full(this.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({Token keyword}) : this.full(keyword);
 
   Token get beginToken => keyword;
@@ skipping 51 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.full(tokens, CommentType.END_OF_LINE, null);
 
   /**
    * The tokens representing the comment.
    */
-  List<Token> tokens;
+  final List<Token> tokens;
 
   /**
    * The type of the comment.
    */
   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;
+  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.full(List<Token> tokens, CommentType type, List<CommentReference> references) {
-    this.references = new NodeList<CommentReference>(this);
-    this.tokens = tokens;
+  Comment.full(this.tokens, CommentType type, List<CommentReference> references) {
+    this._references = new NodeList<CommentReference>(this);
     this._type = type;
-    this.references.addAll(references);
+    this._references.addAll(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({List<Token> tokens, CommentType type, List<CommentReference> references}) : this.full(tokens, type, references);
 
   accept(ASTVisitor visitor) => visitor.visitComment(this);
 
   Token get beginToken => tokens[0];
 
   Token get endToken => tokens[tokens.length - 1];
 
   /**
+   * Return the references embedded within the documentation comment.
+   *
+   * @return the references embedded within the documentation comment
+   */
+  NodeList<CommentReference> get references => _references;
+
+  /**
    * Return `true` if this is a block comment.
    *
    * @return `true` if this is a block comment
    */
   bool get isBlock => identical(_type, CommentType.BLOCK);
 
   /**
    * Return `true` if this is a documentation comment.
    *
    * @return `true` if this is a documentation comment
    */
   bool get isDocumentation => identical(_type, CommentType.DOCUMENTATION);
 
   /**
    * Return `true` if this is an end-of-line comment.
    *
    * @return `true` if this is an end-of-line comment
    */
   bool get isEndOfLine => identical(_type, CommentType.END_OF_LINE);
 
   void visitChildren(ASTVisitor visitor) {
-    references.accept(visitor);
+    _references.accept(visitor);
   }
 }
 
 /**
  * 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.
@@ skipping 36 matching lines @@
    * 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.full(Token newKeyword, Identifier identifier) {
-    this.newKeyword = newKeyword;
+  CommentReference.full(this.newKeyword, Identifier identifier) {
     this._identifier = becomeParentOf(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({Token newKeyword, Identifier identifier}) : this.full(newKeyword, identifier);
@@ skipping 48 matching lines @@
  * declarations ::=
  *     [CompilationUnitMember]*
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class CompilationUnit extends ASTNode {
   /**
    * The first token in the token stream that was parsed to form this compilation unit.
    */
-  Token _beginToken;
+  final 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;
+  NodeList<Directive> _directives;
 
   /**
    * The declarations contained in this compilation unit.
    */
-  NodeList<CompilationUnitMember> declarations;
+  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].
    */
-  Token _endToken;
+  final 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.full(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;
+  CompilationUnit.full(this.beginToken, ScriptTag scriptTag, List<Directive> directives, List<CompilationUnitMember> declarations, this.endToken) {
+    this._directives = new NodeList<Directive>(this);
+    this._declarations = new NodeList<CompilationUnitMember>(this);
     this._scriptTag = becomeParentOf(scriptTag);
-    this.directives.addAll(directives);
-    this.declarations.addAll(declarations);
-    this._endToken = endToken;
+    this._directives.addAll(directives);
+    this._declarations.addAll(declarations);
   }
 
   /**
    * 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({Token beginToken, ScriptTag scriptTag, List<Directive> directives, List<CompilationUnitMember> declarations, Token endToken}) : this.full(beginToken, scriptTag, directives, declarations, endToken);
 
   accept(ASTVisitor visitor) => visitor.visitCompilationUnit(this);
 
-  Token get beginToken => _beginToken;
+  /**
+   * Return the declarations contained in this compilation unit.
+   *
+   * @return the declarations contained in this compilation unit
+   */
+  NodeList<CompilationUnitMember> get declarations => _declarations;
 
-  Token get endToken => _endToken;
+  /**
+   * Return the directives contained in this compilation unit.
+   *
+   * @return the directives contained in this compilation unit
+   */
+  NodeList<Directive> get directives => _directives;
 
   int get length {
     Token endToken = this.endToken;
     if (endToken == null) {
       return 0;
     }
     return endToken.offset + endToken.length;
   }
 
   int get offset => 0;
@@ skipping 11 matching lines @@
    *
    * @param scriptTag the script tag at the beginning of the compilation unit
    */
   void set scriptTag(ScriptTag scriptTag) {
     this._scriptTag = becomeParentOf(scriptTag);
   }
 
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_scriptTag, visitor);
     if (directivesAreBeforeDeclarations()) {
-      directives.accept(visitor);
-      declarations.accept(visitor);
+      _directives.accept(visitor);
+      _declarations.accept(visitor);
     } else {
       for (ASTNode child in sortedDirectivesAndDeclarations) {
         child.accept(visitor);
       }
     }
   }
 
   /**
    * Return `true` if all of the directives are lexically before any declarations.
    *
    * @return `true` if all of the directives are lexically before any declarations
    */
   bool directivesAreBeforeDeclarations() {
-    if (directives.isEmpty || declarations.isEmpty) {
+    if (_directives.isEmpty || _declarations.isEmpty) {
       return true;
     }
-    Directive lastDirective = directives[directives.length - 1];
-    CompilationUnitMember firstDeclaration = declarations[0];
+    Directive lastDirective = _directives[_directives.length - 1];
+    CompilationUnitMember firstDeclaration = _declarations[0];
     return lastDirective.offset < firstDeclaration.offset;
   }
 
   /**
    * Return an array containing all of the directives and declarations in this compilation unit,
    * sorted in lexical order.
    *
    * @return the directives and declarations in this compilation unit in the order in which they
    *         appeared in the original source
    */
   List<ASTNode> get sortedDirectivesAndDeclarations {
     List<ASTNode> childList = new List<ASTNode>();
-    childList.addAll(directives);
-    childList.addAll(declarations);
+    childList.addAll(_directives);
+    childList.addAll(_declarations);
     List<ASTNode> children = new List.from(childList);
     children.sort(ASTNode.LEXICAL_ORDER);
     return children;
   }
 }
 
 /**
  * Instances of the class `CompilationUnitMember` defines the behavior common to nodes that
  * declare a name within the scope of a compilation unit.
  *
@@ skipping 67 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.full(Expression condition, Token question, Expression thenExpression, Token colon, Expression elseExpression) {
+  ConditionalExpression.full(Expression condition, this.question, Expression thenExpression, this.colon, Expression elseExpression) {
     this._condition = becomeParentOf(condition);
-    this.question = question;
     this._thenExpression = becomeParentOf(thenExpression);
-    this.colon = colon;
     this._elseExpression = becomeParentOf(elseExpression);
   }
 
   /**
    * 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`
@@ skipping 136 matching lines @@
 
   /**
    * The token for the separator (colon or equals) before the initializer list or redirection, or
    * `null` if there are no initializers.
    */
   Token separator;
 
   /**
    * The initializers associated with the constructor.
    */
-  NodeList<ConstructorInitializer> initializers;
+  NodeList<ConstructorInitializer> _initializers;
 
   /**
    * The name of the constructor to which this constructor will be redirected, or `null` if
    * this is not a redirecting factory constructor.
    */
   ConstructorName _redirectedConstructor;
 
   /**
    * The body of the constructor, or `null` if the constructor does not have a body.
    */
   FunctionBody _body;
 
   /**
    * The element associated with this constructor, or `null` if the AST structure has not been
    * resolved or if this constructor could not be resolved.
    */
-  ConstructorElement _element;
+  ConstructorElement element;
 
   /**
    * Initialize a newly created constructor declaration.
    *
    * @param externalKeyword the token for the 'external' keyword
    * @param comment the documentation comment associated with this constructor
    * @param metadata the annotations associated with this constructor
    * @param constKeyword the token for the 'const' keyword
    * @param factoryKeyword the token for the 'factory' keyword
    * @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.full(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.full(comment, metadata) {
-    this.initializers = new NodeList<ConstructorInitializer>(this);
-    this.externalKeyword = externalKeyword;
-    this.constKeyword = constKeyword;
-    this.factoryKeyword = factoryKeyword;
+  ConstructorDeclaration.full(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.full(comment, metadata) {
+    this._initializers = new NodeList<ConstructorInitializer>(this);
     this._returnType = becomeParentOf(returnType);
-    this.period = period;
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
-    this.separator = separator;
-    this.initializers.addAll(initializers);
+    this._initializers.addAll(initializers);
     this._redirectedConstructor = becomeParentOf(redirectedConstructor);
     this._body = becomeParentOf(body);
   }
 
   /**
    * Initialize a newly created constructor declaration.
    *
    * @param externalKeyword the token for the 'external' keyword
    * @param comment the documentation comment associated with this constructor
    * @param metadata the annotations associated with this constructor
@@ skipping 13 matching lines @@
 
   accept(ASTVisitor visitor) => visitor.visitConstructorDeclaration(this);
 
   /**
    * Return the body of the constructor, or `null` if the constructor does not have a body.
    *
    * @return the body of the constructor
    */
   FunctionBody get body => _body;
 
-  ConstructorElement get element => _element;
-
   Token get endToken {
     if (_body != null) {
       return _body.endToken;
-    } else if (!initializers.isEmpty) {
-      return initializers.endToken;
+    } else if (!_initializers.isEmpty) {
+      return _initializers.endToken;
     }
     return _parameters.endToken;
   }
 
   /**
+   * Return the initializers associated with the constructor.
+   *
+   * @return the initializers associated with the constructor
+   */
+  NodeList<ConstructorInitializer> get initializers => _initializers;
+
+  /**
    * Return the name of the constructor, or `null` if the constructor being declared is
    * unnamed.
    *
    * @return the name of the constructor
    */
   SimpleIdentifier get name => _name;
 
   /**
    * Return the parameters associated with the constructor.
    *
@@ skipping 21 matching lines @@
   /**
    * Set the body of the constructor to the given function body.
    *
    * @param functionBody the body of the constructor
    */
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
 
   /**
-   * Set the element associated with this constructor to the given element.
-   *
-   * @param element the element associated with this constructor
-   */
-  void set element(ConstructorElement element) {
-    this._element = element;
-  }
-
-  /**
    * Set the name of the constructor to the given identifier.
    *
    * @param identifier the name of the constructor
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
    * Set the parameters associated with the constructor to the given list of parameters.
@@ skipping 22 matching lines @@
    */
   void set returnType(Identifier typeName) {
     _returnType = becomeParentOf(typeName);
   }
 
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_parameters, visitor);
-    initializers.accept(visitor);
+    _initializers.accept(visitor);
     safelyVisitChild(_redirectedConstructor, visitor);
     safelyVisitChild(_body, visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata {
     Token leftMost = this.leftMost([externalKeyword, constKeyword, factoryKeyword]);
     if (leftMost != null) {
       return leftMost;
     }
     return _returnType.beginToken;
@@ skipping 59 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.full(Token keyword, Token period, SimpleIdentifier fieldName, Token equals, Expression expression) {
-    this.keyword = keyword;
-    this.period = period;
+  ConstructorFieldInitializer.full(this.keyword, this.period, SimpleIdentifier fieldName, this.equals, Expression expression) {
     this._fieldName = becomeParentOf(fieldName);
-    this.equals = equals;
     this._expression = becomeParentOf(expression);
   }
 
   /**
    * 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
@@ skipping 102 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.full(TypeName type, Token period, SimpleIdentifier name) {
+  ConstructorName.full(TypeName type, this.period, SimpleIdentifier name) {
     this._type = becomeParentOf(type);
-    this.period = period;
     this._name = becomeParentOf(name);
   }
 
   /**
    * 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
    */
@@ skipping 94 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.full(Token keyword, SimpleIdentifier label, Token semicolon) {
-    this.keyword = keyword;
+  ContinueStatement.full(this.keyword, SimpleIdentifier label, this.semicolon) {
     this._label = becomeParentOf(label);
-    this.semicolon = 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({Token keyword, SimpleIdentifier label, Token semicolon}) : this.full(keyword, label, semicolon);
@@ skipping 77 matching lines @@
 
   /**
    * The name of the declared type of the parameter, or `null` if the parameter does not have
    * a declared type.
    */
   TypeName _type;
 
   /**
    * The name of the variable being declared.
    */
-  SimpleIdentifier identifier;
+  SimpleIdentifier _identifier;
 
   /**
    * 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.full(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, SimpleIdentifier identifier) : super.full(comment, metadata) {
-    this.keyword = keyword;
+  DeclaredIdentifier.full(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, SimpleIdentifier identifier) : super.full(comment, metadata) {
     this._type = becomeParentOf(type);
-    this.identifier = becomeParentOf(identifier);
+    this._identifier = becomeParentOf(identifier);
   }
 
   /**
    * 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, Token keyword, TypeName type, SimpleIdentifier identifier}) : this.full(comment, metadata, keyword, type, identifier);
 
   accept(ASTVisitor visitor) => visitor.visitDeclaredIdentifier(this);
 
   LocalVariableElement get element {
     SimpleIdentifier identifier = this.identifier;
     if (identifier == null) {
       return null;
     }
     return identifier.staticElement as LocalVariableElement;
   }
 
-  Token get endToken => identifier.endToken;
+  Token get endToken => _identifier.endToken;
+
+  /**
+   * Return the name of the variable being declared.
+   *
+   * @return the name of the variable being declared
+   */
+  SimpleIdentifier get identifier => _identifier;
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the parameter does
    * not have a declared type.
    *
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
 
   /**
@@ skipping 17 matching lines @@
    *
    * @param typeName the name of the declared type of the parameter
    */
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
 
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
-    safelyVisitChild(identifier, visitor);
+    safelyVisitChild(_identifier, visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
-    return identifier.beginToken;
+    return _identifier.beginToken;
   }
 }
 
 /**
  * Instances of the class `DefaultFormalParameter` represent a formal parameter with a default
  * value. There are two kinds of parameters that are both represented by this class: named formal
  * parameters and positional formal parameters.
  *
  * <pre>
  * defaultFormalParameter ::=
  *     [NormalFormalParameter] ('=' [Expression])?
  *
  * defaultNamedParameter ::=
  *     [NormalFormalParameter] (':' [Expression])?
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class DefaultFormalParameter extends FormalParameter {
   /**
    * The formal parameter with which the default value is associated.
    */
   NormalFormalParameter _parameter;
 
   /**
    * The kind of this parameter.
    */
-  ParameterKind _kind;
+  ParameterKind kind;
 
   /**
    * The token separating the parameter from the default value, or `null` if there is no
    * default value.
    */
   Token separator;
 
   /**
    * The expression computing the default value for the parameter, or `null` if there is no
    * default value.
    */
   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.full(NormalFormalParameter parameter, ParameterKind kind, Token separator, Expression defaultValue) {
+  DefaultFormalParameter.full(NormalFormalParameter parameter, this.kind, this.separator, Expression defaultValue) {
     this._parameter = becomeParentOf(parameter);
-    this._kind = kind;
-    this.separator = separator;
     this._defaultValue = becomeParentOf(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
@@ skipping 14 matching lines @@
 
   Token get endToken {
     if (_defaultValue != null) {
       return _defaultValue.endToken;
     }
     return _parameter.endToken;
   }
 
   SimpleIdentifier get identifier => _parameter.identifier;
 
-  ParameterKind get kind => _kind;
-
   /**
    * Return the formal parameter with which the default value is associated.
    *
    * @return the formal parameter with which the default value is associated
    */
   NormalFormalParameter get parameter => _parameter;
 
   bool get isConst => _parameter != null && _parameter.isConst;
 
   bool get isFinal => _parameter != null && _parameter.isFinal;
 
   /**
    * Set the expression computing the default value for the parameter to the given expression.
    *
    * @param expression the expression computing the default value for the parameter
    */
   void set defaultValue(Expression expression) {
     _defaultValue = becomeParentOf(expression);
   }
 
   /**
-   * Set the kind of this parameter to the given kind.
-   *
-   * @param kind the kind of this parameter
-   */
-  void set kind(ParameterKind kind) {
-    this._kind = kind;
-  }
-
-  /**
    * Set the formal parameter with which the default value is associated to the given parameter.
    *
    * @param formalParameter the formal parameter with which the default value is associated
    */
   void set parameter(NormalFormalParameter formalParameter) {
     _parameter = becomeParentOf(formalParameter);
   }
 
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_parameter, visitor);
@@ skipping 116 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.full(Token doKeyword, Statement body, Token whileKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon) {
-    this.doKeyword = doKeyword;
+  DoStatement.full(this.doKeyword, Statement body, this.whileKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, this.semicolon) {
     this._body = becomeParentOf(body);
-    this.whileKeyword = whileKeyword;
     this._leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
     this._rightParenthesis = rightParenthesis;
-    this.semicolon = semicolon;
   }
 
   /**
    * 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
@@ skipping 102 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.full(Token literal, double value) {
-    this.literal = literal;
-    this.value = value;
-  }
+  DoubleLiteral.full(this.literal, this.value);
 
   /**
    * Initialize a newly created floating point literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   DoubleLiteral({Token literal, double value}) : this.full(literal, value);
 
   accept(ASTVisitor visitor) => visitor.visitDoubleLiteral(this);
@@ skipping 21 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.full(Token semicolon) {
-    this.semicolon = semicolon;
-  }
+  EmptyFunctionBody.full(this.semicolon);
 
   /**
    * Initialize a newly created function body.
    *
    * @param semicolon the token representing the semicolon that marks the end of the function body
    */
   EmptyFunctionBody({Token semicolon}) : this.full(semicolon);
 
   accept(ASTVisitor visitor) => visitor.visitEmptyFunctionBody(this);
 
@@ skipping 19 matching lines @@
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created empty statement.
    *
    * @param semicolon the semicolon terminating the statement
    */
-  EmptyStatement.full(Token semicolon) {
-    this.semicolon = semicolon;
-  }
+  EmptyStatement.full(this.semicolon);
 
   /**
    * Initialize a newly created empty statement.
    *
    * @param semicolon the semicolon terminating the statement
    */
   EmptyStatement({Token semicolon}) : this.full(semicolon);
 
   accept(ASTVisitor visitor) => visitor.visitEmptyStatement(this);
 
@@ skipping 251 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.full(Token functionDefinition, Expression expression, Token semicolon) {
-    this.functionDefinition = functionDefinition;
+  ExpressionFunctionBody.full(this.functionDefinition, Expression expression, this.semicolon) {
     this._expression = becomeParentOf(expression);
-    this.semicolon = 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
    */
@@ skipping 52 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.full(Expression expression, Token semicolon) {
+  ExpressionStatement.full(Expression expression, this.semicolon) {
     this._expression = becomeParentOf(expression);
-    this.semicolon = 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, Token semicolon}) : this.full(expression, semicolon);
 
@@ skipping 52 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.full(Token keyword, TypeName superclass) {
-    this.keyword = keyword;
+  ExtendsClause.full(this.keyword, TypeName superclass) {
     this._superclass = becomeParentOf(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({Token keyword, TypeName superclass}) : this.full(keyword, superclass);
@@ skipping 54 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.full(Comment comment, List<Annotation> metadata, Token staticKeyword, VariableDeclarationList fieldList, Token semicolon) : super.full(comment, metadata) {
-    this.staticKeyword = staticKeyword;
+  FieldDeclaration.full(Comment comment, List<Annotation> metadata, this.staticKeyword, VariableDeclarationList fieldList, this.semicolon) : super.full(comment, metadata) {
     this._fieldList = becomeParentOf(fieldList);
-    this.semicolon = semicolon;
   }
 
   /**
    * 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
@@ skipping 87 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.full(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, Token thisToken, Token period, SimpleIdentifier identifier, FormalParameterList parameters) : super.full(comment, metadata, identifier) {
-    this.keyword = keyword;
+  FieldFormalParameter.full(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, this.thisToken, this.period, SimpleIdentifier identifier, FormalParameterList parameters) : super.full(comment, metadata, identifier) {
     this._type = becomeParentOf(type);
-    this.thisToken = thisToken;
-    this.period = period;
     this._parameters = becomeParentOf(parameters);
   }
 
   /**
    * 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
@@ skipping 121 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_full(Token forKeyword, Token leftParenthesis, DeclaredIdentifier loopVariable, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body) {
-    this.forKeyword = forKeyword;
-    this.leftParenthesis = leftParenthesis;
+  ForEachStatement.con1_full(this.forKeyword, this.leftParenthesis, DeclaredIdentifier loopVariable, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
     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 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({Token forKeyword, Token leftParenthesis, DeclaredIdentifier loopVariable, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body}) : this.con1_full(forKeyword, leftParenthesis, loopVariable, inKeyword, iterator, rightParenthesis, 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_full(Token forKeyword, Token leftParenthesis, SimpleIdentifier identifier, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body) {
-    this.forKeyword = forKeyword;
-    this.leftParenthesis = leftParenthesis;
+  ForEachStatement.con2_full(this.forKeyword, this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
     this._identifier = becomeParentOf(identifier);
-    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
@@ skipping 135 matching lines @@
   Expression _condition;
 
   /**
    * The semicolon separating the condition and the updater.
    */
   Token rightSeparator;
 
   /**
    * The list of expressions run after each execution of the loop body.
    */
-  NodeList<Expression> updaters;
+  NodeList<Expression> _updaters;
 
   /**
    * The right parenthesis.
    */
   Token rightParenthesis;
 
   /**
    * The body of the loop.
    */
   Statement _body;
 
   /**
    * Initialize a newly created for statement.
    *
    * @param forKeyword the token representing the 'for' keyword
    * @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.full(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;
+  ForStatement.full(this.forKeyword, this.leftParenthesis, VariableDeclarationList variableList, Expression initialization, this.leftSeparator, Expression condition, this.rightSeparator, List<Expression> updaters, this.rightParenthesis, Statement body) {
+    this._updaters = new NodeList<Expression>(this);
     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._updaters.addAll(updaters);
     this._body = becomeParentOf(body);
   }
 
   /**
    * Initialize a newly created for statement.
    *
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
    * @param variableList the declaration of the loop variables
    * @param initialization the initialization expression
@@ skipping 28 matching lines @@
   Token get endToken => _body.endToken;
 
   /**
    * Return the initialization expression, or `null` if there is no initialization expression.
    *
    * @return the initialization expression
    */
   Expression get initialization => _initialization;
 
   /**
+   * Return the list of expressions run after each execution of the loop body.
+   *
+   * @return the list of expressions run after each execution of the loop body
+   */
+  NodeList<Expression> get updaters => _updaters;
+
+  /**
    * Return the declaration of the loop variables, or `null` if there are no variables.
    *
    * @return the declaration of the loop variables, or `null` if there are no variables
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the body of the loop to the given statement.
    *
    * @param body the body of the loop
@@ skipping 26 matching lines @@
    * @param variableList the declaration of the loop variables
    */
   void set variables(VariableDeclarationList variableList) {
     variableList = becomeParentOf(variableList);
   }
 
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_variableList, visitor);
     safelyVisitChild(_initialization, visitor);
     safelyVisitChild(_condition, visitor);
-    updaters.accept(visitor);
+    _updaters.accept(visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * The abstract class `FormalParameter` defines the behavior of objects representing a
  * parameter to a function.
  *
  * <pre>
  * formalParameter ::=
@@ skipping 83 matching lines @@
  */
 class FormalParameterList extends ASTNode {
   /**
    * The left parenthesis.
    */
   Token _leftParenthesis;
 
   /**
    * The parameters associated with the method.
    */
-  NodeList<FormalParameter> parameters;
+  NodeList<FormalParameter> _parameters;
 
   /**
    * The left square bracket ('[') or left curly brace ('{') introducing the optional parameters, or
    * `null` if there are no optional parameters.
    */
   Token _leftDelimiter;
 
   /**
    * The right square bracket (']') or right curly brace ('}') introducing the optional parameters,
    * or `null` if there are no optional parameters.
    */
   Token _rightDelimiter;
 
   /**
    * The right parenthesis.
    */
   Token _rightParenthesis;
 
   /**
    * Initialize a newly created parameter list.
    *
    * @param leftParenthesis the left parenthesis
    * @param parameters the parameters associated with the method
    * @param leftDelimiter the left delimiter introducing the optional parameters
    * @param rightDelimiter the right delimiter introducing the optional parameters
    * @param rightParenthesis the right parenthesis
    */
   FormalParameterList.full(Token leftParenthesis, List<FormalParameter> parameters, Token leftDelimiter, Token rightDelimiter, Token rightParenthesis) {
-    this.parameters = new NodeList<FormalParameter>(this);
+    this._parameters = new NodeList<FormalParameter>(this);
     this._leftParenthesis = leftParenthesis;
-    this.parameters.addAll(parameters);
+    this._parameters.addAll(parameters);
     this._leftDelimiter = leftDelimiter;
     this._rightDelimiter = rightDelimiter;
     this._rightParenthesis = rightParenthesis;
   }
 
   /**
    * Initialize a newly created parameter list.
    *
    * @param leftParenthesis the left parenthesis
    * @param parameters the parameters associated with the method
@@ skipping 25 matching lines @@
    */
   Token get leftParenthesis => _leftParenthesis;
 
   /**
    * Return an array containing the elements representing the parameters in this list. The array
    * will contain `null`s if the parameters in this list have not been resolved.
    *
    * @return the elements representing the parameters in this list
    */
   List<ParameterElement> get parameterElements {
-    int count = parameters.length;
+    int count = _parameters.length;
     List<ParameterElement> types = new List<ParameterElement>(count);
     for (int i = 0; i < count; i++) {
-      types[i] = parameters[i].element;
+      types[i] = _parameters[i].element;
     }
     return types;
   }
 
   /**
+   * Return the parameters associated with the method.
+   *
+   * @return the parameters associated with the method
+   */
+  NodeList<FormalParameter> get parameters => _parameters;
+
+  /**
    * Return the right square bracket (']') or right curly brace ('}') introducing the optional
    * parameters, or `null` if there are no optional parameters.
    *
    * @return the right square bracket (']') or right curly brace ('}') introducing the optional
    *         parameters
    */
   Token get rightDelimiter => _rightDelimiter;
 
   /**
    * Return the right parenthesis.
@@ skipping 34 matching lines @@
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
 
   void visitChildren(ASTVisitor visitor) {
-    parameters.accept(visitor);
+    _parameters.accept(visitor);
   }
 }
 
 /**
  * The abstract class `FunctionBody` defines the behavior common to objects representing the
  * body of a function or method.
  *
  * <pre>
  * functionBody ::=
  *     [BlockFunctionBody]
@@ skipping 52 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.full(Comment comment, List<Annotation> metadata, Token externalKeyword, TypeName returnType, Token propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression) : super.full(comment, metadata) {
-    this.externalKeyword = externalKeyword;
+  FunctionDeclaration.full(Comment comment, List<Annotation> metadata, this.externalKeyword, TypeName returnType, this.propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression) : super.full(comment, metadata) {
     this._returnType = becomeParentOf(returnType);
-    this.propertyKeyword = propertyKeyword;
     this._name = becomeParentOf(name);
     this._functionExpression = becomeParentOf(functionExpression);
   }
 
   /**
    * 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
@@ skipping 97 matching lines @@
 /**
  * Instances of the class `FunctionDeclarationStatement` wrap a [FunctionDeclaration
  ] as a statement.
  *
  * @coverage dart.engine.ast
  */
 class FunctionDeclarationStatement extends Statement {
   /**
    * The function declaration being wrapped.
    */
-  FunctionDeclaration functionDeclaration;
+  FunctionDeclaration _functionDeclaration;
 
   /**
    * Initialize a newly created function declaration statement.
    *
    * @param functionDeclaration the the function declaration being wrapped
    */
   FunctionDeclarationStatement.full(FunctionDeclaration functionDeclaration) {
-    this.functionDeclaration = becomeParentOf(functionDeclaration);
+    this._functionDeclaration = becomeParentOf(functionDeclaration);
   }
 
   /**
    * Initialize a newly created function declaration statement.
    *
    * @param functionDeclaration the the function declaration being wrapped
    */
   FunctionDeclarationStatement({FunctionDeclaration functionDeclaration}) : this.full(functionDeclaration);
 
   accept(ASTVisitor visitor) => visitor.visitFunctionDeclarationStatement(this);
 
-  Token get beginToken => functionDeclaration.beginToken;
+  Token get beginToken => _functionDeclaration.beginToken;
 
-  Token get endToken => functionDeclaration.endToken;
+  Token get endToken => _functionDeclaration.endToken;
+
+  /**
+   * Return the function declaration being wrapped.
+   *
+   * @return the function declaration being wrapped
+   */
+  FunctionDeclaration get functionDeclaration => _functionDeclaration;
 
   /**
    * Set the function declaration being wrapped to the given function declaration.
    *
    * @param functionDeclaration the function declaration being wrapped
    */
   void set functionExpression(FunctionDeclaration functionDeclaration) {
-    this.functionDeclaration = becomeParentOf(functionDeclaration);
+    this._functionDeclaration = becomeParentOf(functionDeclaration);
   }
 
   void visitChildren(ASTVisitor visitor) {
-    safelyVisitChild(functionDeclaration, visitor);
+    safelyVisitChild(_functionDeclaration, visitor);
   }
 }
 
 /**
  * Instances of the class `FunctionExpression` represent a function expression.
  *
  * <pre>
  * functionExpression ::=
  *     [FormalParameterList] [FunctionBody]
  * </pre>
@@ skipping 495 matching lines @@
  * hideCombinator ::=
  *     'hide' [SimpleIdentifier] (',' [SimpleIdentifier])*
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class HideCombinator extends Combinator {
   /**
    * The list of names from the library that are hidden by this combinator.
    */
-  NodeList<SimpleIdentifier> hiddenNames;
+  NodeList<SimpleIdentifier> _hiddenNames;
 
   /**
    * Initialize a newly created import show combinator.
    *
    * @param keyword the comma introducing the combinator
    * @param hiddenNames the list of names from the library that are hidden by this combinator
    */
   HideCombinator.full(Token keyword, List<SimpleIdentifier> hiddenNames) : super.full(keyword) {
-    this.hiddenNames = new NodeList<SimpleIdentifier>(this);
-    this.hiddenNames.addAll(hiddenNames);
+    this._hiddenNames = new NodeList<SimpleIdentifier>(this);
+    this._hiddenNames.addAll(hiddenNames);
   }
 
   /**
    * Initialize a newly created import show combinator.
    *
    * @param keyword the comma introducing the combinator
    * @param hiddenNames the list of names from the library that are hidden by this combinator
    */
   HideCombinator({Token keyword, List<SimpleIdentifier> hiddenNames}) : this.full(keyword, hiddenNames);
 
   accept(ASTVisitor visitor) => visitor.visitHideCombinator(this);
 
-  Token get endToken => hiddenNames.endToken;
+  Token get endToken => _hiddenNames.endToken;
+
+  /**
+   * Return the list of names from the library that are hidden by this combinator.
+   *
+   * @return the list of names from the library that are hidden by this combinator
+   */
+  NodeList<SimpleIdentifier> get hiddenNames => _hiddenNames;
 
   void visitChildren(ASTVisitor visitor) {
-    hiddenNames.accept(visitor);
+    _hiddenNames.accept(visitor);
   }
 }
 
 /**
  * The abstract class `Identifier` defines the behavior common to nodes that represent an
  * identifier.
  *
  * <pre>
  * identifier ::=
  *     [SimpleIdentifier]
@@ skipping 103 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.full(Token ifKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Statement thenStatement, Token elseKeyword, Statement elseStatement) {
-    this.ifKeyword = ifKeyword;
-    this.leftParenthesis = leftParenthesis;
+  IfStatement.full(this.ifKeyword, this.leftParenthesis, Expression condition, this.rightParenthesis, Statement thenStatement, this.elseKeyword, Statement elseStatement) {
     this._condition = becomeParentOf(condition);
-    this.rightParenthesis = rightParenthesis;
     this._thenStatement = becomeParentOf(thenStatement);
-    this.elseKeyword = elseKeyword;
     this._elseStatement = becomeParentOf(elseStatement);
   }
 
   /**
    * 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
@@ skipping 86 matching lines @@
  */
 class ImplementsClause extends ASTNode {
   /**
    * The token representing the 'implements' keyword.
    */
   Token keyword;
 
   /**
    * The interfaces that are being implemented.
    */
-  NodeList<TypeName> interfaces;
+  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.full(Token keyword, List<TypeName> interfaces) {
-    this.interfaces = new NodeList<TypeName>(this);
-    this.keyword = keyword;
-    this.interfaces.addAll(interfaces);
+  ImplementsClause.full(this.keyword, List<TypeName> interfaces) {
+    this._interfaces = new NodeList<TypeName>(this);
+    this._interfaces.addAll(interfaces);
   }
 
   /**
    * Initialize a newly created implements clause.
    *
    * @param keyword the token representing the 'implements' keyword
    * @param interfaces the interfaces that are being implemented
    */
   ImplementsClause({Token keyword, List<TypeName> interfaces}) : this.full(keyword, interfaces);
 
   accept(ASTVisitor visitor) => visitor.visitImplementsClause(this);
 
   Token get beginToken => keyword;
 
-  Token get endToken => interfaces.endToken;
+  Token get endToken => _interfaces.endToken;
+
+  /**
+   * Return the list of the interfaces that are being implemented.
+   *
+   * @return the list of the interfaces that are being implemented
+   */
+  NodeList<TypeName> get interfaces => _interfaces;
 
   void visitChildren(ASTVisitor visitor) {
-    interfaces.accept(visitor);
+    _interfaces.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `ImportDirective` represent an import directive.
  *
  * <pre>
  * importDirective ::=
  *     [Annotation] 'import' [StringLiteral] ('as' identifier)? [Combinator]* ';'
  * </pre>
@@ skipping 97 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.full(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, Token asToken, SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon) : super.full(comment, metadata, keyword, libraryUri, combinators, semicolon) {
-    this.asToken = asToken;
+  ImportDirective.full(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, this.asToken, SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon) : super.full(comment, metadata, keyword, libraryUri, combinators, semicolon) {
     this._prefix = becomeParentOf(prefix);
   }
 
   /**
    * Initialize a newly created import 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' keyword
    * @param libraryUri the URI of the library being imported
@@ skipping 125 matching lines @@
   IndexExpression.forTarget({Expression target, Token leftBracket, Expression index, Token rightBracket}) : this.forTarget_full(target, leftBracket, index, rightBracket);
 
   /**
    * 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_full(Token period, Token leftBracket, Expression index, Token rightBracket) {
-    this.period = period;
+  IndexExpression.forCascade_full(this.period, Token leftBracket, Expression index, Token rightBracket) {
     this._leftBracket = leftBracket;
     this._index = becomeParentOf(index);
     this._rightBracket = rightBracket;
   }
 
   /**
    * Initialize a newly created index expression.
    *
    * @param period the period ("..") before a cascaded index expression
    * @param leftBracket the left square bracket
@@ skipping 294 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.full(Token keyword, ConstructorName constructorName, ArgumentList argumentList) {
-    this.keyword = keyword;
+  InstanceCreationExpression.full(this.keyword, ConstructorName constructorName, ArgumentList argumentList) {
     this.constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * 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
@@ skipping 65 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.full(Token literal, int value) {
-    this.literal = literal;
-    this.value = value;
-  }
+  IntegerLiteral.full(this.literal, this.value);
 
   /**
    * Initialize a newly created integer literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   IntegerLiteral({Token literal, int value}) : this.full(literal, value);
 
   accept(ASTVisitor visitor) => visitor.visitIntegerLiteral(this);
@@ skipping 50 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.full(Token leftBracket, Expression expression, Token rightBracket) {
-    this.leftBracket = leftBracket;
+  InterpolationExpression.full(this.leftBracket, Expression expression, this.rightBracket) {
     this._expression = becomeParentOf(expression);
-    this.rightBracket = 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({Token leftBracket, Expression expression, Token rightBracket}) : this.full(leftBracket, expression, rightBracket);
@@ skipping 146 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.full(Expression expression, Token isOperator, Token notOperator, TypeName type) {
+  IsExpression.full(Expression expression, this.isOperator, this.notOperator, TypeName type) {
     this._expression = becomeParentOf(expression);
-    this.isOperator = isOperator;
-    this.notOperator = notOperator;
     this._type = becomeParentOf(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
@@ skipping 67 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.full(SimpleIdentifier label, Token colon) {
+  Label.full(SimpleIdentifier label, this.colon) {
     this._label = becomeParentOf(label);
-    this.colon = 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, Token colon}) : this.full(label, colon);
 
@@ skipping 32 matching lines @@
  * labeledStatement ::=
  *    [Label]+ [Statement]
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class LabeledStatement extends Statement {
   /**
    * The labels being associated with the statement.
    */
-  NodeList<Label> labels;
+  NodeList<Label> _labels;
 
   /**
    * The statement with which the labels are being associated.
    */
   Statement _statement;
 
   /**
    * Initialize a newly created labeled statement.
    *
    * @param labels the labels being associated with the statement
    * @param statement the statement with which the labels are being associated
    */
   LabeledStatement.full(List<Label> labels, Statement statement) {
-    this.labels = new NodeList<Label>(this);
-    this.labels.addAll(labels);
+    this._labels = new NodeList<Label>(this);
+    this._labels.addAll(labels);
     this._statement = becomeParentOf(statement);
   }
 
   /**
    * Initialize a newly created labeled statement.
    *
    * @param labels the labels being associated with the statement
    * @param statement the statement with which the labels are being associated
    */
   LabeledStatement({List<Label> labels, Statement statement}) : this.full(labels, statement);
 
   accept(ASTVisitor visitor) => visitor.visitLabeledStatement(this);
 
   Token get beginToken {
-    if (!labels.isEmpty) {
-      return labels.beginToken;
+    if (!_labels.isEmpty) {
+      return _labels.beginToken;
     }
     return _statement.beginToken;
   }
 
   Token get endToken => _statement.endToken;
 
   /**
+   * Return the labels being associated with the statement.
+   *
+   * @return the labels being associated with the statement
+   */
+  NodeList<Label> get labels => _labels;
+
+  /**
    * Return the statement with which the labels are being associated.
    *
    * @return the statement with which the labels are being associated
    */
   Statement get statement => _statement;
 
   /**
    * Set the statement with which the labels are being associated to the given statement.
    *
    * @param statement the statement with which the labels are being associated
    */
   void set statement(Statement statement) {
     this._statement = becomeParentOf(statement);
   }
 
   void visitChildren(ASTVisitor visitor) {
-    labels.accept(visitor);
+    _labels.accept(visitor);
     safelyVisitChild(_statement, visitor);
   }
 }
 
 /**
  * Instances of the class `LibraryDirective` represent a library directive.
  *
  * <pre>
  * libraryDirective ::=
  *     [Annotation] 'library' [Identifier] ';'
@@ skipping 19 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.full(Comment comment, List<Annotation> metadata, Token libraryToken, LibraryIdentifier name, Token semicolon) : super.full(comment, metadata) {
-    this.libraryToken = libraryToken;
+  LibraryDirective.full(Comment comment, List<Annotation> metadata, this.libraryToken, LibraryIdentifier name, this.semicolon) : super.full(comment, metadata) {
     this._name = becomeParentOf(name);
-    this.semicolon = semicolon;
   }
 
   /**
    * 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
@@ skipping 37 matching lines @@
  * libraryIdentifier ::=
  *     [SimpleIdentifier] ('.' [SimpleIdentifier])*
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class LibraryIdentifier extends Identifier {
   /**
    * The components of the identifier.
    */
-  NodeList<SimpleIdentifier> components;
+  NodeList<SimpleIdentifier> _components;
 
   /**
    * Initialize a newly created prefixed identifier.
    *
    * @param components the components of the identifier
    */
   LibraryIdentifier.full(List<SimpleIdentifier> components) {
-    this.components = new NodeList<SimpleIdentifier>(this);
-    this.components.addAll(components);
+    this._components = new NodeList<SimpleIdentifier>(this);
+    this._components.addAll(components);
   }
 
   /**
    * Initialize a newly created prefixed identifier.
    *
    * @param components the components of the identifier
    */
   LibraryIdentifier({List<SimpleIdentifier> components}) : this.full(components);
 
   accept(ASTVisitor visitor) => visitor.visitLibraryIdentifier(this);
 
-  Token get beginToken => components.beginToken;
+  Token get beginToken => _components.beginToken;
 
   Element get bestElement => staticElement;
 
-  Token get endToken => components.endToken;
+  /**
+   * Return the components of the identifier.
+   *
+   * @return the components of the identifier
+   */
+  NodeList<SimpleIdentifier> get components => _components;
+
+  Token get endToken => _components.endToken;
 
   String get name {
     JavaStringBuilder builder = new JavaStringBuilder();
     bool needsPeriod = false;
-    for (SimpleIdentifier identifier in components) {
+    for (SimpleIdentifier identifier in _components) {
       if (needsPeriod) {
         builder.append(".");
       } else {
         needsPeriod = true;
       }
       builder.append(identifier.name);
     }
     return builder.toString();
   }
 
   int get precedence => 15;
 
   Element get propagatedElement => null;
 
   Element get staticElement => null;
 
   void visitChildren(ASTVisitor visitor) {
-    components.accept(visitor);
+    _components.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `ListLiteral` represent a list literal.
  *
  * <pre>
  * listLiteral ::=
  *     'const'? ('<' [TypeName] '>')? '[' ([Expression] ','?)? ']'
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class ListLiteral extends TypedLiteral {
   /**
    * The left square bracket.
    */
   Token _leftBracket;
 
   /**
    * The expressions used to compute the elements of the list.
    */
-  NodeList<Expression> elements;
+  NodeList<Expression> _elements;
 
   /**
    * The right square bracket.
    */
   Token _rightBracket;
 
   /**
    * Initialize a newly created list 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
    * @param leftBracket the left square bracket
    * @param elements the expressions used to compute the elements of the list
    * @param rightBracket the right square bracket
    */
   ListLiteral.full(Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket) : super.full(constKeyword, typeArguments) {
-    this.elements = new NodeList<Expression>(this);
+    this._elements = new NodeList<Expression>(this);
     this._leftBracket = leftBracket;
-    this.elements.addAll(elements);
+    this._elements.addAll(elements);
     this._rightBracket = rightBracket;
   }
 
   /**
    * Initialize a newly created list 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
    * @param leftBracket the left square bracket
    * @param elements the expressions used to compute the elements of the list
    * @param rightBracket the right square bracket
    */
   ListLiteral({Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket}) : this.full(constKeyword, typeArguments, leftBracket, elements, rightBracket);
 
   accept(ASTVisitor visitor) => visitor.visitListLiteral(this);
 
   Token get beginToken {
     Token token = constKeyword;
     if (token != null) {
       return token;
     }
     TypeArgumentList typeArguments = this.typeArguments;
     if (typeArguments != null) {
       return typeArguments.beginToken;
     }
     return _leftBracket;
   }
 
+  /**
+   * Return the expressions used to compute the elements of the list.
+   *
+   * @return the expressions used to compute the elements of the list
+   */
+  NodeList<Expression> get elements => _elements;
+
   Token get endToken => _rightBracket;
 
   /**
    * Return the left square bracket.
    *
    * @return the left square bracket
    */
   Token get leftBracket => _leftBracket;
 
   /**
@@ skipping 16 matching lines @@
    * Set the right square bracket to the given token.
    *
    * @param bracket the right square bracket
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
 
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
-    elements.accept(visitor);
+    _elements.accept(visitor);
   }
 }
 
 /**
  * The abstract class `Literal` defines the behavior common to nodes that represent a literal
  * expression.
  *
  * <pre>
  * literal ::=
  *     [BooleanLiteral]
@@ skipping 23 matching lines @@
  */
 class MapLiteral extends TypedLiteral {
   /**
    * The left curly bracket.
    */
   Token _leftBracket;
 
   /**
    * The entries in the map.
    */
-  NodeList<MapLiteralEntry> entries;
+  NodeList<MapLiteralEntry> _entries;
 
   /**
    * The right curly bracket.
    */
   Token _rightBracket;
 
   /**
    * Initialize a newly created map 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
    * @param leftBracket the left curly bracket
    * @param entries the entries in the map
    * @param rightBracket the right curly bracket
    */
   MapLiteral.full(Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket) : super.full(constKeyword, typeArguments) {
-    this.entries = new NodeList<MapLiteralEntry>(this);
+    this._entries = new NodeList<MapLiteralEntry>(this);
     this._leftBracket = leftBracket;
-    this.entries.addAll(entries);
+    this._entries.addAll(entries);
     this._rightBracket = rightBracket;
   }
 
   /**
    * Initialize a newly created map 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
    * @param leftBracket the left curly bracket
@@ skipping 12 matching lines @@
     TypeArgumentList typeArguments = this.typeArguments;
     if (typeArguments != null) {
       return typeArguments.beginToken;
     }
     return _leftBracket;
   }
 
   Token get endToken => _rightBracket;
 
   /**
+   * Return the entries in the map.
+   *
+   * @return the entries in the map
+   */
+  NodeList<MapLiteralEntry> get entries => _entries;
+
+  /**
    * Return the left curly bracket.
    *
    * @return the left curly bracket
    */
   Token get leftBracket => _leftBracket;
 
   /**
    * Return the right curly bracket.
    *
    * @return the right curly bracket
@@ skipping 13 matching lines @@
    * Set the right curly bracket to the given token.
    *
    * @param bracket the right curly bracket
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
 
   void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
-    entries.accept(visitor);
+    _entries.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `MapLiteralEntry` represent a single key/value pair in a map
  * literal.
  *
  * <pre>
  * mapLiteralEntry ::=
  *     [Expression] ':' [Expression]
@@ skipping 17 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.full(Expression key, Token separator, Expression value) {
+  MapLiteralEntry.full(Expression key, this.separator, Expression value) {
     this._key = becomeParentOf(key);
-    this.separator = separator;
     this._value = becomeParentOf(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
    */
@@ skipping 115 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.full(Comment comment, List<Annotation> metadata, Token externalKeyword, Token modifierKeyword, TypeName returnType, Token propertyKeyword, Token operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body) : super.full(comment, metadata) {
-    this.externalKeyword = externalKeyword;
-    this.modifierKeyword = modifierKeyword;
+  MethodDeclaration.full(Comment comment, List<Annotation> metadata, this.externalKeyword, this.modifierKeyword, TypeName returnType, this.propertyKeyword, this.operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body) : super.full(comment, metadata) {
     this._returnType = becomeParentOf(returnType);
-    this.propertyKeyword = propertyKeyword;
-    this.operatorKeyword = operatorKeyword;
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
     this._body = becomeParentOf(body);
   }
 
   /**
    * Initialize a newly created method declaration.
    *
    * @param externalKeyword the token for the 'external' keyword
    * @param comment the documentation comment associated with this method
@@ skipping 183 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.full(Expression target, Token period, SimpleIdentifier methodName, ArgumentList argumentList) {
+  MethodInvocation.full(Expression target, this.period, SimpleIdentifier methodName, ArgumentList argumentList) {
     this._target = becomeParentOf(target);
-    this.period = period;
     this._methodName = becomeParentOf(methodName);
     this._argumentList = becomeParentOf(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
@@ skipping 217 matching lines @@
  *     [ExportDirective]
  *   | [ImportDirective]
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 abstract class NamespaceDirective extends UriBasedDirective {
   /**
    * The token representing the 'import' or 'export' keyword.
    */
-  Token _keyword;
+  Token keyword;
 
   /**
    * The combinators used to control which names are imported or exported.
    */
-  NodeList<Combinator> combinators;
+  NodeList<Combinator> _combinators;
 
   /**
    * The semicolon terminating the directive.
    */
   Token semicolon;
 
   /**
    * 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.full(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon) : super.full(comment, metadata, libraryUri) {
-    this.combinators = new NodeList<Combinator>(this);
-    this._keyword = keyword;
-    this.combinators.addAll(combinators);
-    this.semicolon = semicolon;
+  NamespaceDirective.full(Comment comment, List<Annotation> metadata, this.keyword, StringLiteral libraryUri, List<Combinator> combinators, this.semicolon) : super.full(comment, metadata, libraryUri) {
+    this._combinators = new NodeList<Combinator>(this);
+    this._combinators.addAll(combinators);
   }
 
   /**
    * 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, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon}) : this.full(comment, metadata, keyword, libraryUri, combinators, 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;
+
   Token get endToken => semicolon;
 
-  Token get keyword => _keyword;
-
   LibraryElement get uriElement;
 
-  /**
-   * Set the token representing the 'import' or 'export' keyword to the given token.
-   *
-   * @param exportToken the token representing the 'import' or 'export' keyword
-   */
-  void set keyword(Token exportToken) {
-    this._keyword = exportToken;
-  }
-
-  Token get firstTokenAfterCommentAndMetadata => _keyword;
+  Token get firstTokenAfterCommentAndMetadata => keyword;
 }
 
 /**
  * Instances of the class `NativeClause` represent the "native" clause in an class
  * declaration.
  *
  * <pre>
  * nativeClause ::=
  *     'native' [StringLiteral]
  * </pre>
@@ skipping 10 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.full(Token keyword, StringLiteral name) {
-    this.keyword = keyword;
-    this.name = name;
-  }
+  NativeClause.full(this.keyword, this.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({Token keyword, StringLiteral name}) : this.full(keyword, name);
 
   accept(ASTVisitor visitor) => visitor.visitNativeClause(this);
@@ skipping 15 matching lines @@
  * nativeFunctionBody ::=
  *     'native' [SimpleStringLiteral] ';'
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class NativeFunctionBody extends FunctionBody {
   /**
    * The token representing 'native' that marks the start of the function body.
    */
-  Token nativeToken;
+  final Token nativeToken;
 
   /**
    * The string literal, after the 'native' token.
    */
-  StringLiteral stringLiteral;
+  StringLiteral _stringLiteral;
 
   /**
    * The token representing the semicolon that marks the end of the function body.
    */
-  Token semicolon;
+  final 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.full(Token nativeToken, StringLiteral stringLiteral, Token semicolon) {
-    this.nativeToken = nativeToken;
-    this.stringLiteral = becomeParentOf(stringLiteral);
-    this.semicolon = semicolon;
+  NativeFunctionBody.full(this.nativeToken, StringLiteral stringLiteral, this.semicolon) {
+    this._stringLiteral = becomeParentOf(stringLiteral);
   }
 
   /**
    * 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({Token nativeToken, StringLiteral stringLiteral, Token semicolon}) : this.full(nativeToken, stringLiteral, semicolon);
 
   accept(ASTVisitor visitor) => visitor.visitNativeFunctionBody(this);
 
   Token get beginToken => nativeToken;
 
   Token get endToken => semicolon;
 
+  /**
+   * Return the string literal representing the string after the 'native' token.
+   *
+   * @return the string literal representing the string after the 'native' token
+   */
+  StringLiteral get stringLiteral => _stringLiteral;
+
   void visitChildren(ASTVisitor visitor) {
-    safelyVisitChild(stringLiteral, visitor);
+    safelyVisitChild(_stringLiteral, visitor);
   }
 }
 
 /**
  * The abstract class `NormalFormalParameter` defines the behavior common to formal parameters
  * that are required (are not optional).
  *
  * <pre>
  * normalFormalParameter ::=
  *     [FunctionTypedFormalParameter]
  *   | [FieldFormalParameter]
  *   | [SimpleFormalParameter]
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 abstract class NormalFormalParameter extends FormalParameter {
   /**
    * The documentation comment associated with this parameter, or `null` if this parameter
    * does not have a documentation comment associated with it.
    */
   Comment _comment;
 
   /**
    * The annotations associated with this parameter.
    */
-  NodeList<Annotation> metadata;
+  NodeList<Annotation> _metadata;
 
   /**
    * The name of the parameter being declared.
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created formal parameter.
    *
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param identifier the name of the parameter being declared
    */
   NormalFormalParameter.full(Comment comment, List<Annotation> metadata, SimpleIdentifier identifier) {
-    this.metadata = new NodeList<Annotation>(this);
+    this._metadata = new NodeList<Annotation>(this);
     this._comment = becomeParentOf(comment);
-    this.metadata.addAll(metadata);
+    this._metadata.addAll(metadata);
     this._identifier = becomeParentOf(identifier);
   }
 
   /**
    * Initialize a newly created formal parameter.
    *
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param identifier the name of the parameter being declared
    */
@@ skipping 11 matching lines @@
 
   ParameterKind get kind {
     ASTNode parent = this.parent;
     if (parent is DefaultFormalParameter) {
       return (parent as DefaultFormalParameter).kind;
     }
     return ParameterKind.REQUIRED;
   }
 
   /**
+   * Return the annotations associated with this parameter.
+   *
+   * @return the annotations associated with this parameter
+   */
+  NodeList<Annotation> get metadata => _metadata;
+
+  /**
    * Set the documentation comment associated with this parameter to the given comment
    *
    * @param comment the documentation comment to be associated with this parameter
    */
   void set documentationComment(Comment comment) {
     this._comment = becomeParentOf(comment);
   }
 
   /**
    * Set the name of the parameter being declared to the given identifier.
    *
    * @param identifier the name of the parameter being declared
    */
   void set identifier(SimpleIdentifier identifier) {
     this._identifier = becomeParentOf(identifier);
   }
 
   void visitChildren(ASTVisitor visitor) {
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
-      metadata.accept(visitor);
+      _metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
   }
 
   /**
    * Return `true` if the comment is lexically before any annotations.
    *
    * @return `true` if the comment is lexically before any annotations
    */
   bool commentIsBeforeAnnotations() {
-    if (_comment == null || metadata.isEmpty) {
+    if (_comment == null || _metadata.isEmpty) {
       return true;
     }
-    Annotation firstAnnotation = metadata[0];
+    Annotation firstAnnotation = _metadata[0];
     return _comment.offset < firstAnnotation.offset;
   }
 
   /**
    * Return an array containing the comment and annotations associated with this parameter, sorted
    * in lexical order.
    *
    * @return the comment and annotations associated with this parameter in the order in which they
    *         appeared in the original source
    */
   List<ASTNode> get sortedCommentAndAnnotations {
     List<ASTNode> childList = new List<ASTNode>();
     childList.add(_comment);
-    childList.addAll(metadata);
+    childList.addAll(_metadata);
     List<ASTNode> children = new List.from(childList);
     children.sort(ASTNode.LEXICAL_ORDER);
     return children;
   }
 }
 
 /**
  * Instances of the class `NullLiteral` represent a null literal expression.
  *
  * <pre>
@@ skipping 167 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.full(Comment comment, List<Annotation> metadata, Token partToken, StringLiteral partUri, Token semicolon) : super.full(comment, metadata, partUri) {
-    this.partToken = partToken;
-    this.semicolon = semicolon;
-  }
+  PartDirective.full(Comment comment, List<Annotation> metadata, this.partToken, StringLiteral partUri, this.semicolon) : super.full(comment, metadata, partUri);
 
   /**
    * 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
    */
@@ skipping 44 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.full(Comment comment, List<Annotation> metadata, Token partToken, Token ofToken, LibraryIdentifier libraryName, Token semicolon) : super.full(comment, metadata) {
-    this.partToken = partToken;
-    this.ofToken = ofToken;
+  PartOfDirective.full(Comment comment, List<Annotation> metadata, this.partToken, this.ofToken, LibraryIdentifier libraryName, this.semicolon) : super.full(comment, metadata) {
     this._libraryName = becomeParentOf(libraryName);
-    this.semicolon = semicolon;
   }
 
   /**
    * 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
@@ skipping 65 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.full(Expression operand, Token operator) {
+  PostfixExpression.full(Expression operand, this.operator) {
     this._operand = becomeParentOf(operand);
-    this.operator = operator;
   }
 
   /**
    * 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, Token operator}) : this.full(operand, operator);
 
@@ skipping 158 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.full(Token operator, Expression operand) {
-    this.operator = operator;
+  PrefixExpression.full(this.operator, Expression operand) {
     this._operand = becomeParentOf(operand);
   }
 
   /**
    * 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({Token operator, Expression operand}) : this.full(operator, operand);
@@ skipping 153 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.full(SimpleIdentifier prefix, Token period, SimpleIdentifier identifier) {
+  PrefixedIdentifier.full(SimpleIdentifier prefix, this.period, SimpleIdentifier identifier) {
     this._prefix = becomeParentOf(prefix);
-    this.period = period;
     this._identifier = becomeParentOf(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
    */
@@ skipping 99 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.full(Expression target, Token operator, SimpleIdentifier propertyName) {
+  PropertyAccess.full(Expression target, this.operator, SimpleIdentifier propertyName) {
     this._target = becomeParentOf(target);
-    this.operator = operator;
     this._propertyName = becomeParentOf(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
    */
@@ skipping 129 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.full(Token keyword, Token period, SimpleIdentifier constructorName, ArgumentList argumentList) {
-    this.keyword = keyword;
-    this.period = period;
+  RedirectingConstructorInvocation.full(this.keyword, this.period, SimpleIdentifier constructorName, ArgumentList argumentList) {
     this._constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * 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
@@ skipping 61 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.full(Token keyword) {
-    this.keyword = keyword;
-  }
+  RethrowExpression.full(this.keyword);
 
   /**
    * Initialize a newly created rethrow expression.
    *
    * @param keyword the token representing the 'rethrow' keyword
    */
   RethrowExpression({Token keyword}) : this.full(keyword);
 
   accept(ASTVisitor visitor) => visitor.visitRethrowExpression(this);
 
@@ skipping 34 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.full(Token keyword, Expression expression, Token semicolon) {
-    this.keyword = keyword;
+  ReturnStatement.full(this.keyword, Expression expression, this.semicolon) {
     this._expression = becomeParentOf(expression);
-    this.semicolon = 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({Token keyword, Expression expression, Token semicolon}) : this.full(keyword, expression, semicolon);
@@ skipping 41 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.full(Token scriptTag) {
-    this.scriptTag = scriptTag;
-  }
+  ScriptTag.full(this.scriptTag);
 
   /**
    * Initialize a newly created script tag.
    *
    * @param scriptTag the token representing this script tag
    */
   ScriptTag({Token scriptTag}) : this.full(scriptTag);
 
   accept(ASTVisitor visitor) => visitor.visitScriptTag(this);
 
@@ skipping 13 matching lines @@
  * showCombinator ::=
  *     'show' [SimpleIdentifier] (',' [SimpleIdentifier])*
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class ShowCombinator extends Combinator {
   /**
    * The list of names from the library that are made visible by this combinator.
    */
-  NodeList<SimpleIdentifier> shownNames;
+  NodeList<SimpleIdentifier> _shownNames;
 
   /**
    * Initialize a newly created import show combinator.
    *
    * @param keyword the comma introducing the combinator
    * @param shownNames the list of names from the library that are made visible by this combinator
    */
   ShowCombinator.full(Token keyword, List<SimpleIdentifier> shownNames) : super.full(keyword) {
-    this.shownNames = new NodeList<SimpleIdentifier>(this);
-    this.shownNames.addAll(shownNames);
+    this._shownNames = new NodeList<SimpleIdentifier>(this);
+    this._shownNames.addAll(shownNames);
   }
 
   /**
    * Initialize a newly created import show combinator.
    *
    * @param keyword the comma introducing the combinator
    * @param shownNames the list of names from the library that are made visible by this combinator
    */
   ShowCombinator({Token keyword, List<SimpleIdentifier> shownNames}) : this.full(keyword, shownNames);
 
   accept(ASTVisitor visitor) => visitor.visitShowCombinator(this);
 
-  Token get endToken => shownNames.endToken;
+  Token get endToken => _shownNames.endToken;
+
+  /**
+   * Return the list of names from the library that are made visible by this combinator.
+   *
+   * @return the list of names from the library that are made visible by this combinator
+   */
+  NodeList<SimpleIdentifier> get shownNames => _shownNames;
 
   void visitChildren(ASTVisitor visitor) {
-    shownNames.accept(visitor);
+    _shownNames.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `SimpleFormalParameter` represent a simple formal parameter.
  *
  * <pre>
  * simpleFormalParameter ::=
  *     ('final' [TypeName] | 'var' | [TypeName])? [SimpleIdentifier]
  * </pre>
@@ skipping 15 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.full(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, SimpleIdentifier identifier) : super.full(comment, metadata, identifier) {
-    this.keyword = keyword;
+  SimpleFormalParameter.full(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, SimpleIdentifier identifier) : super.full(comment, metadata, identifier) {
     this._type = becomeParentOf(type);
   }
 
   /**
    * 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
@@ skipping 80 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.full(Token token) {
-    this.token = token;
-  }
+  SimpleIdentifier.full(this.token);
 
   /**
    * Initialize a newly created identifier.
    *
    * @param token the token representing the identifier
    */
   SimpleIdentifier({Token token}) : this.full(token);
 
   accept(ASTVisitor visitor) => visitor.visitSimpleIdentifier(this);
 
@@ skipping 240 matching lines @@
    * The value of the literal.
    */
   String _value;
 
   /**
    * Initialize a newly created simple string literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
-  SimpleStringLiteral.full(Token literal, String value) {
-    this.literal = literal;
+  SimpleStringLiteral.full(this.literal, String value) {
     this._value = StringUtilities.intern(value);
   }
 
   /**
    * Initialize a newly created simple string literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   SimpleStringLiteral({Token literal, String value}) : this.full(literal, value);
@@ skipping 84 matching lines @@
  *     ''' [InterpolationElement]* '''
  *   | '"' [InterpolationElement]* '"'
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class StringInterpolation extends StringLiteral {
   /**
    * The elements that will be composed to produce the resulting string.
    */
-  NodeList<InterpolationElement> elements;
+  NodeList<InterpolationElement> _elements;
 
   /**
    * Initialize a newly created string interpolation expression.
    *
    * @param elements the elements that will be composed to produce the resulting string
    */
   StringInterpolation.full(List<InterpolationElement> elements) {
-    this.elements = new NodeList<InterpolationElement>(this);
-    this.elements.addAll(elements);
+    this._elements = new NodeList<InterpolationElement>(this);
+    this._elements.addAll(elements);
   }
 
   /**
    * Initialize a newly created string interpolation expression.
    *
    * @param elements the elements that will be composed to produce the resulting string
    */
   StringInterpolation({List<InterpolationElement> elements}) : this.full(elements);
 
   accept(ASTVisitor visitor) => visitor.visitStringInterpolation(this);
 
-  Token get beginToken => elements.beginToken;
+  Token get beginToken => _elements.beginToken;
 
-  Token get endToken => elements.endToken;
+  /**
+   * Return the elements that will be composed to produce the resulting string.
+   *
+   * @return the elements that will be composed to produce the resulting string
+   */
+  NodeList<InterpolationElement> get elements => _elements;
+
+  Token get endToken => _elements.endToken;
 
   void visitChildren(ASTVisitor visitor) {
-    elements.accept(visitor);
+    _elements.accept(visitor);
   }
 
   void appendStringValue(JavaStringBuilder builder) {
     throw new IllegalArgumentException();
   }
 }
 
 /**
  * Instances of the class `StringLiteral` represent a string literal expression.
  *
@@ skipping 75 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.full(Token keyword, Token period, SimpleIdentifier constructorName, ArgumentList argumentList) {
-    this.keyword = keyword;
-    this.period = period;
+  SuperConstructorInvocation.full(this.keyword, this.period, SimpleIdentifier constructorName, ArgumentList argumentList) {
     this._constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * 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
@@ skipping 61 matching lines @@
   /**
    * The token representing the keyword.
    */
   Token keyword;
 
   /**
    * Initialize a newly created super expression.
    *
    * @param keyword the token representing the keyword
    */
-  SuperExpression.full(Token keyword) {
-    this.keyword = keyword;
-  }
+  SuperExpression.full(this.keyword);
 
   /**
    * Initialize a newly created super expression.
    *
    * @param keyword the token representing the keyword
    */
   SuperExpression({Token keyword}) : this.full(keyword);
 
   accept(ASTVisitor visitor) => visitor.visitSuperExpression(this);
 
@@ skipping 120 matching lines @@
  *     switchCase
  *   | switchDefault
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 abstract class SwitchMember extends ASTNode {
   /**
    * The labels associated with the switch member.
    */
-  NodeList<Label> labels;
+  NodeList<Label> _labels;
 
   /**
    * The token representing the 'case' or 'default' keyword.
    */
   Token keyword;
 
   /**
    * The colon separating the keyword or the expression from the statements.
    */
   Token colon;
 
   /**
    * The statements that will be executed if this switch member is selected.
    */
-  NodeList<Statement> statements;
+  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.full(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);
+  SwitchMember.full(List<Label> labels, this.keyword, this.colon, List<Statement> statements) {
+    this._labels = new NodeList<Label>(this);
+    this._statements = new NodeList<Statement>(this);
+    this._labels.addAll(labels);
+    this._statements.addAll(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, Token keyword, Token colon, List<Statement> statements}) : this.full(labels, keyword, colon, statements);
 
   Token get beginToken {
-    if (!labels.isEmpty) {
-      return labels.beginToken;
+    if (!_labels.isEmpty) {
+      return _labels.beginToken;
     }
     return keyword;
   }
 
   Token get endToken {
-    if (!statements.isEmpty) {
-      return statements.endToken;
+    if (!_statements.isEmpty) {
+      return _statements.endToken;
     }
     return colon;
   }
+
+  /**
+   * Return the labels associated with the switch member.
+   *
+   * @return the labels associated with the switch member
+   */
+  NodeList<Label> get labels => _labels;
+
+  /**
+   * Return the statements that will be executed if this switch member is selected.
+   *
+   * @return the statements that will be executed if this switch member is selected
+   */
+  NodeList<Statement> get statements => _statements;
 }
 
 /**
  * Instances of the class `SwitchStatement` represent a switch statement.
  *
  * <pre>
  * switchStatement ::=
  *     'switch' '(' [Expression] ')' '{' [SwitchCase]* [SwitchDefault]? '}'
  * </pre>
  *
@@ skipping 21 matching lines @@
   Token rightParenthesis;
 
   /**
    * The left curly bracket.
    */
   Token leftBracket;
 
   /**
    * The switch members that can be selected by the expression.
    */
-  NodeList<SwitchMember> members;
+  NodeList<SwitchMember> _members;
 
   /**
    * The right curly bracket.
    */
   Token rightBracket;
 
   /**
    * 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.full(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;
+  SwitchStatement.full(this.keyword, this.leftParenthesis, Expression expression, this.rightParenthesis, this.leftBracket, List<SwitchMember> members, this.rightBracket) {
+    this._members = new NodeList<SwitchMember>(this);
     this._expression = becomeParentOf(expression);
-    this.rightParenthesis = rightParenthesis;
-    this.leftBracket = leftBracket;
-    this.members.addAll(members);
-    this.rightBracket = rightBracket;
+    this._members.addAll(members);
   }
 
   /**
    * 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({Token keyword, Token leftParenthesis, Expression expression, Token rightParenthesis, Token leftBracket, List<SwitchMember> members, Token rightBracket}) : this.full(keyword, leftParenthesis, expression, rightParenthesis, leftBracket, members, rightBracket);
 
   accept(ASTVisitor visitor) => visitor.visitSwitchStatement(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => rightBracket;
 
   /**
    * Return the expression used to determine which of the switch members will be selected.
    *
    * @return the expression used to determine which of the switch members will be selected
    */
   Expression get expression => _expression;
 
   /**
+   * Return the switch members that can be selected by the expression.
+   *
+   * @return the switch members that can be selected by the expression
+   */
+  NodeList<SwitchMember> get members => _members;
+
+  /**
    * Set the expression used to determine which of the switch members will be selected to the given
    * expression.
    *
    * @param expression the expression used to determine which of the switch members will be selected
    */
   void set expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
-    members.accept(visitor);
+    _members.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `SymbolLiteral` represent a symbol literal expression.
  *
  * <pre>
  * symbolLiteral ::=
  *     '#' (operator | (identifier ('.' identifier)*))
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class SymbolLiteral extends Literal {
   /**
    * The token introducing the literal.
    */
   Token poundSign;
 
   /**
    * The components of the literal.
    */
-  List<Token> components;
+  final List<Token> components;
 
   /**
    * Initialize a newly created symbol literal.
    *
    * @param poundSign the token introducing the literal
    * @param components the components of the literal
    */
-  SymbolLiteral.full(Token poundSign, List<Token> components) {
-    this.poundSign = poundSign;
-    this.components = components;
-  }
+  SymbolLiteral.full(this.poundSign, this.components);
 
   /**
    * Initialize a newly created symbol literal.
    *
    * @param poundSign the token introducing the literal
    * @param components the components of the literal
    */
   SymbolLiteral({Token poundSign, List<Token> components}) : this.full(poundSign, components);
 
   accept(ASTVisitor visitor) => visitor.visitSymbolLiteral(this);
@@ skipping 20 matching lines @@
   /**
    * The token representing the keyword.
    */
   Token keyword;
 
   /**
    * Initialize a newly created this expression.
    *
    * @param keyword the token representing the keyword
    */
-  ThisExpression.full(Token keyword) {
-    this.keyword = keyword;
-  }
+  ThisExpression.full(this.keyword);
 
   /**
    * Initialize a newly created this expression.
    *
    * @param keyword the token representing the keyword
    */
   ThisExpression({Token keyword}) : this.full(keyword);
 
   accept(ASTVisitor visitor) => visitor.visitThisExpression(this);
 
@@ skipping 27 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.full(Token keyword, Expression expression) {
-    this.keyword = keyword;
+  ThrowExpression.full(this.keyword, Expression expression) {
     this._expression = becomeParentOf(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({Token keyword, Expression expression}) : this.full(keyword, expression);
@@ skipping 56 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.full(Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, Token semicolon) : super.full(comment, metadata) {
+  TopLevelVariableDeclaration.full(Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, this.semicolon) : super.full(comment, metadata) {
     this._variableList = becomeParentOf(variableList);
-    this.semicolon = 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
    */
@@ skipping 49 matching lines @@
   Token tryKeyword;
 
   /**
    * The body of the statement.
    */
   Block _body;
 
   /**
    * The catch clauses contained in the try statement.
    */
-  NodeList<CatchClause> catchClauses;
+  NodeList<CatchClause> _catchClauses;
 
   /**
    * The token representing the 'finally' keyword, or `null` if the statement does not contain
    * a finally clause.
    */
   Token finallyKeyword;
 
   /**
    * The finally block contained in the try statement, or `null` if the statement does not
    * contain a finally clause.
    */
   Block _finallyBlock;
 
   /**
    * 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.full(Token tryKeyword, Block body, List<CatchClause> catchClauses, Token finallyKeyword, Block finallyBlock) {
-    this.catchClauses = new NodeList<CatchClause>(this);
-    this.tryKeyword = tryKeyword;
+  TryStatement.full(this.tryKeyword, Block body, List<CatchClause> catchClauses, this.finallyKeyword, Block finallyBlock) {
+    this._catchClauses = new NodeList<CatchClause>(this);
     this._body = becomeParentOf(body);
-    this.catchClauses.addAll(catchClauses);
-    this.finallyKeyword = finallyKeyword;
+    this._catchClauses.addAll(catchClauses);
     this._finallyBlock = becomeParentOf(finallyBlock);
   }
 
   /**
    * 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({Token tryKeyword, Block body, List<CatchClause> catchClauses, Token finallyKeyword, Block finallyBlock}) : this.full(tryKeyword, body, catchClauses, finallyKeyword, finallyBlock);
 
   accept(ASTVisitor visitor) => visitor.visitTryStatement(this);
 
   Token get beginToken => tryKeyword;
 
   /**
    * Return the body of the statement.
    *
    * @return the body of the statement
    */
   Block get body => _body;
 
+  /**
+   * Return the catch clauses contained in the try statement.
+   *
+   * @return the catch clauses contained in the try statement
+   */
+  NodeList<CatchClause> get catchClauses => _catchClauses;
+
   Token get endToken {
     if (_finallyBlock != null) {
       return _finallyBlock.endToken;
     } else if (finallyKeyword != null) {
       return finallyKeyword;
-    } else if (!catchClauses.isEmpty) {
-      return catchClauses.endToken;
+    } else if (!_catchClauses.isEmpty) {
+      return _catchClauses.endToken;
     }
     return _body.endToken;
   }
 
   /**
    * Return the finally block contained in the try statement, or `null` if the statement does
    * not contain a finally clause.
    *
    * @return the finally block contained in the try statement
    */
@@ skipping 12 matching lines @@
    * Set the finally block contained in the try statement to the given block.
    *
    * @param block the finally block contained in the try statement
    */
   void set finallyBlock(Block block) {
     _finallyBlock = becomeParentOf(block);
   }
 
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_body, visitor);
-    catchClauses.accept(visitor);
+    _catchClauses.accept(visitor);
     safelyVisitChild(_finallyBlock, visitor);
   }
 }
 
 /**
  * The abstract class `TypeAlias` defines the behavior common to declarations of type aliases.
  *
  * <pre>
  * typeAlias ::=
  *     'typedef' typeAliasBody
@@ skipping 17 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.full(Comment comment, List<Annotation> metadata, Token keyword, Token semicolon) : super.full(comment, metadata) {
-    this.keyword = keyword;
-    this.semicolon = semicolon;
-  }
+  TypeAlias.full(Comment comment, List<Annotation> metadata, this.keyword, this.semicolon) : super.full(comment, metadata);
 
   /**
    * 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, Token keyword, Token semicolon}) : this.full(comment, metadata, keyword, semicolon);
@@ skipping 15 matching lines @@
  */
 class TypeArgumentList extends ASTNode {
   /**
    * The left bracket.
    */
   Token leftBracket;
 
   /**
    * The type arguments associated with the type.
    */
-  NodeList<TypeName> arguments;
+  NodeList<TypeName> _arguments;
 
   /**
    * The right bracket.
    */
   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.full(Token leftBracket, List<TypeName> arguments, Token rightBracket) {
-    this.arguments = new NodeList<TypeName>(this);
-    this.leftBracket = leftBracket;
-    this.arguments.addAll(arguments);
-    this.rightBracket = rightBracket;
+  TypeArgumentList.full(this.leftBracket, List<TypeName> arguments, this.rightBracket) {
+    this._arguments = new NodeList<TypeName>(this);
+    this._arguments.addAll(arguments);
   }
 
   /**
    * 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({Token leftBracket, List<TypeName> arguments, Token rightBracket}) : this.full(leftBracket, arguments, rightBracket);
 
   accept(ASTVisitor visitor) => visitor.visitTypeArgumentList(this);
 
+  /**
+   * Return the type arguments associated with the type.
+   *
+   * @return the type arguments associated with the type
+   */
+  NodeList<TypeName> get arguments => _arguments;
+
   Token get beginToken => leftBracket;
 
   Token get endToken => rightBracket;
 
   void visitChildren(ASTVisitor visitor) {
-    arguments.accept(visitor);
+    _arguments.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `TypeName` represent the name of a type, which can optionally
  * include type arguments.
  *
  * <pre>
  * typeName ::=
  *     [Identifier] typeArguments?
@@ skipping 120 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.full(Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token keyword, TypeName bound) : super.full(comment, metadata) {
+  TypeParameter.full(Comment comment, List<Annotation> metadata, SimpleIdentifier name, this.keyword, TypeName bound) : super.full(comment, metadata) {
     this._name = becomeParentOf(name);
-    this.keyword = keyword;
     this._bound = becomeParentOf(bound);
   }
 
   /**
    * 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
@@ skipping 61 matching lines @@
  * typeParameterList ::=
  *     '<' [TypeParameter] (',' [TypeParameter])* '>'
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class TypeParameterList extends ASTNode {
   /**
    * The left angle bracket.
    */
-  Token leftBracket;
+  final Token leftBracket;
 
   /**
    * The type parameters in the list.
    */
-  NodeList<TypeParameter> typeParameters;
+  NodeList<TypeParameter> _typeParameters;
 
   /**
    * The right angle bracket.
    */
-  Token rightBracket;
+  final 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.full(Token leftBracket, List<TypeParameter> typeParameters, Token rightBracket) {
-    this.typeParameters = new NodeList<TypeParameter>(this);
-    this.leftBracket = leftBracket;
-    this.typeParameters.addAll(typeParameters);
-    this.rightBracket = rightBracket;
+  TypeParameterList.full(this.leftBracket, List<TypeParameter> typeParameters, this.rightBracket) {
+    this._typeParameters = new NodeList<TypeParameter>(this);
+    this._typeParameters.addAll(typeParameters);
   }
 
   /**
    * 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({Token leftBracket, List<TypeParameter> typeParameters, Token rightBracket}) : this.full(leftBracket, typeParameters, rightBracket);
 
   accept(ASTVisitor visitor) => visitor.visitTypeParameterList(this);
 
   Token get beginToken => leftBracket;
 
   Token get endToken => rightBracket;
 
+  /**
+   * Return the type parameters for the type.
+   *
+   * @return the type parameters for the type
+   */
+  NodeList<TypeParameter> get typeParameters => _typeParameters;
+
   void visitChildren(ASTVisitor visitor) {
-    typeParameters.accept(visitor);
+    _typeParameters.accept(visitor);
   }
 }
 
 /**
  * The abstract class `TypedLiteral` defines the behavior common to literals that have a type
  * associated with them.
  *
  * <pre>
  * listLiteral ::=
  *     [ListLiteral]
@@ skipping 14 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.full(Token constKeyword, TypeArgumentList typeArguments) {
-    this.constKeyword = constKeyword;
+  TypedLiteral.full(this.constKeyword, TypeArgumentList typeArguments) {
     this.typeArguments = becomeParentOf(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
    */
@@ skipping 106 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.full(Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token equals, Expression initializer) : super.full(comment, metadata) {
+  VariableDeclaration.full(Comment comment, List<Annotation> metadata, SimpleIdentifier name, this.equals, Expression initializer) : super.full(comment, metadata) {
     this._name = becomeParentOf(name);
-    this.equals = equals;
     this._initializer = becomeParentOf(initializer);
   }
 
   /**
    * 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
@@ skipping 118 matching lines @@
   Token keyword;
 
   /**
    * The type of the variables being declared, or `null` if no type was provided.
    */
   TypeName _type;
 
   /**
    * A list containing the individual variables being declared.
    */
-  NodeList<VariableDeclaration> variables;
+  NodeList<VariableDeclaration> _variables;
 
   /**
    * 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.full(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, List<VariableDeclaration> variables) : super.full(comment, metadata) {
-    this.variables = new NodeList<VariableDeclaration>(this);
-    this.keyword = keyword;
+  VariableDeclarationList.full(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, List<VariableDeclaration> variables) : super.full(comment, metadata) {
+    this._variables = new NodeList<VariableDeclaration>(this);
     this._type = becomeParentOf(type);
-    this.variables.addAll(variables);
+    this._variables.addAll(variables);
   }
 
   /**
    * 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, Token keyword, TypeName type, List<VariableDeclaration> variables}) : this.full(comment, metadata, keyword, type, variables);
 
   accept(ASTVisitor visitor) => visitor.visitVariableDeclarationList(this);
 
-  Token get endToken => variables.endToken;
+  Token get endToken => _variables.endToken;
 
   /**
    * Return the type of the variables being declared, or `null` if no type was provided.
    *
    * @return the type of the variables being declared
    */
   TypeName get type => _type;
 
   /**
+   * Return a list containing the individual variables being declared.
+   *
+   * @return a list containing the individual variables being declared
+   */
+  NodeList<VariableDeclaration> get variables => _variables;
+
+  /**
    * Return `true` if the variables in this list were declared with the 'const' modifier.
    *
    * @return `true` if the variables in this list were declared with the 'const' modifier
    */
   bool get isConst => keyword is KeywordToken && identical((keyword as KeywordToken).keyword, Keyword.CONST);
 
   /**
    * Return `true` if the variables in this list were declared with the 'final' modifier.
    * Variables that are declared with the 'const' modifier will return `false` even though
    * they are implicitly final.
    *
    * @return `true` if the variables in this list were declared with the 'final' modifier
    */
   bool get isFinal => keyword is KeywordToken && identical((keyword as KeywordToken).keyword, Keyword.FINAL);
 
   /**
    * Set the type of the variables being declared to the given type name.
    *
    * @param typeName the type of the variables being declared
    */
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
 
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_type, visitor);
-    variables.accept(visitor);
+    _variables.accept(visitor);
   }
 
   Token get firstTokenAfterCommentAndMetadata {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
-    return variables.beginToken;
+    return _variables.beginToken;
   }
 }
 
 /**
  * Instances of the class `VariableDeclarationStatement` represent a list of variables that
  * are being declared in a context where a statement is required.
  *
  * <pre>
  * variableDeclarationStatement ::=
  *     [VariableDeclarationList] ';'
@@ skipping 11 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.full(VariableDeclarationList variableList, Token semicolon) {
+  VariableDeclarationStatement.full(VariableDeclarationList variableList, this.semicolon) {
     this._variableList = becomeParentOf(variableList);
-    this.semicolon = semicolon;
   }
 
   /**
    * Initialize a newly created variable declaration statement.
    *
    * @param variableList the fields being declared
    * @param semicolon the semicolon terminating the statement
    */
   VariableDeclarationStatement({VariableDeclarationList variableList, Token semicolon}) : this.full(variableList, semicolon);
 
@@ skipping 62 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.full(Token keyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Statement body) {
-    this.keyword = keyword;
-    this.leftParenthesis = leftParenthesis;
+  WhileStatement.full(this.keyword, this.leftParenthesis, Expression condition, this.rightParenthesis, Statement body) {
     this._condition = becomeParentOf(condition);
-    this.rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
 
   /**
    * 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
@@ skipping 53 matching lines @@
  * withClause ::=
  *     'with' [TypeName] (',' [TypeName])*
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class WithClause extends ASTNode {
   /**
    * The token representing the 'with' keyword.
    */
-  Token withKeyword;
+  Token _withKeyword;
 
   /**
    * The names of the mixins that were specified.
    */
-  NodeList<TypeName> mixinTypes;
+  NodeList<TypeName> _mixinTypes;
 
   /**
    * Initialize a newly created with clause.
    *
    * @param withKeyword the token representing the 'with' keyword
    * @param mixinTypes the names of the mixins that were specified
    */
   WithClause.full(Token withKeyword, List<TypeName> mixinTypes) {
-    this.mixinTypes = new NodeList<TypeName>(this);
-    this.withKeyword = withKeyword;
-    this.mixinTypes.addAll(mixinTypes);
+    this._mixinTypes = new NodeList<TypeName>(this);
+    this._withKeyword = withKeyword;
+    this._mixinTypes.addAll(mixinTypes);
   }
 
   /**
    * Initialize a newly created with clause.
    *
    * @param withKeyword the token representing the 'with' keyword
    * @param mixinTypes the names of the mixins that were specified
    */
   WithClause({Token withKeyword, List<TypeName> mixinTypes}) : this.full(withKeyword, mixinTypes);
 
   accept(ASTVisitor visitor) => visitor.visitWithClause(this);
 
-  Token get beginToken => withKeyword;
+  Token get beginToken => _withKeyword;
 
-  Token get endToken => mixinTypes.endToken;
+  Token get endToken => _mixinTypes.endToken;
+
+  /**
+   * Return the names of the mixins that were specified.
+   *
+   * @return the names of the mixins that were specified
+   */
+  NodeList<TypeName> get mixinTypes => _mixinTypes;
+
+  /**
+   * Return the token representing the 'with' keyword.
+   *
+   * @return the token representing the 'with' keyword
+   */
+  Token get withKeyword => _withKeyword;
 
   /**
    * Set the token representing the 'with' keyword to the given token.
    *
    * @param withKeyword the token representing the 'with' keyword
    */
   void set mixinKeyword(Token withKeyword) {
-    this.withKeyword = withKeyword;
+    this._withKeyword = withKeyword;
   }
 
   void visitChildren(ASTVisitor visitor) {
-    mixinTypes.accept(visitor);
+    _mixinTypes.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `BreadthFirstVisitor` implement an AST visitor that will recursively
  * visit all of the nodes in an AST structure, similar to [GeneralizingASTVisitor]. This
  * visitor uses a breadth-first ordering rather than the depth-first ordering of
  * [GeneralizingASTVisitor].
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or
@@ skipping 757 matching lines @@
 
   /**
    * The end offset of the range used to identify the node.
    */
   int _endOffset = 0;
 
   /**
    * The element that was found that corresponds to the given source range, or `null` if there
    * is no such element.
    */
-  ASTNode foundNode;
+  ASTNode _foundNode;
 
   /**
    * Initialize a newly created locator to locate one or more [ASTNode] by locating
    * the node within an AST structure that corresponds to the given offset in the source.
    *
    * @param offset the offset used to identify the node
    */
   NodeLocator.con1(int offset) : this.con2(offset, offset);
 
   /**
    * Initialize a newly created locator to locate one or more [ASTNode] by locating
    * the node within an AST structure that corresponds to the given range of characters in the
    * source.
    *
    * @param start the start offset of the range used to identify the node
    * @param end the end offset of the range used to identify the node
    */
   NodeLocator.con2(int start, int end) {
     this._startOffset = start;
     this._endOffset = end;
   }
 
   /**
+   * Return the node that was found that corresponds to the given source range, or `null` if
+   * there is no such node.
+   *
+   * @return the node that was found
+   */
+  ASTNode get foundNode => _foundNode;
+
+  /**
    * Search within the given AST node for an identifier representing a [DartElement] in the specified source range. Return the element that was found, or `null` if
    * no element was found.
    *
    * @param node the AST node within which to search
    * @return the element that was found
    */
   ASTNode searchWithin(ASTNode node) {
     if (node == null) {
       return null;
     }
     try {
       node.accept(this);
     } on NodeLocator_NodeFoundException catch (exception) {
     } on JavaException catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Unable to locate element at offset (${_startOffset} - ${_endOffset})", exception);
       return null;
     }
-    return foundNode;
+    return _foundNode;
   }
 
   Object visitNode(ASTNode node) {
     int start = node.offset;
     int end = start + node.length;
     if (end < _startOffset) {
       return null;
     }
     if (start > _endOffset) {
       return null;
     }
     try {
       node.visitChildren(this);
     } on NodeLocator_NodeFoundException catch (exception) {
       throw exception;
     } on JavaException catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Exception caught while traversing an AST structure.", exception);
     }
     if (start <= _startOffset && _endOffset <= end) {
-      foundNode = node;
+      _foundNode = node;
       throw new NodeLocator_NodeFoundException();
     }
     return null;
   }
 }
 
 /**
  * Instances of the class `NodeFoundException` are used to cancel visiting after a node has
  * been found.
  */
@@ skipping 3209 matching lines @@
 
   ReturnStatement visitReturnStatement(ReturnStatement node) => new ReturnStatement.full(map(node.keyword), clone4(node.expression), map(node.semicolon));
 
   ScriptTag visitScriptTag(ScriptTag node) => new ScriptTag.full(map(node.scriptTag));
 
   ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator.full(map(node.keyword), clone5(node.shownNames));
 
   SimpleFormalParameter visitSimpleFormalParameter(SimpleFormalParameter node) => new SimpleFormalParameter.full(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.type), clone4(node.identifier));
 
   SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) {
-    SimpleIdentifier copy = new SimpleIdentifier.full(map(node.token));
+    Token mappedToken = map(node.token);
+    if (mappedToken == null) {
+      mappedToken = node.token;
+    }
+    SimpleIdentifier copy = new SimpleIdentifier.full(mappedToken);
     copy.auxiliaryElements = node.auxiliaryElements;
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) {
     SimpleStringLiteral copy = new SimpleStringLiteral.full(map(node.literal), node.value);
@@ skipping 113 matching lines @@
  * Traverse the AST from initial child node to successive parents, building a collection of local
  * variable and parameter names visible to the initial child node. In case of name shadowing, the
  * first name seen is the most specific one so names are not redefined.
  *
  * Completion test code coverage is 95%. The two basic blocks that are not executed cannot be
  * executed. They are included for future reference.
  *
  * @coverage com.google.dart.engine.services.completion
  */
 class ScopedNameFinder extends GeneralizingASTVisitor<Object> {
-  Declaration declaration;
+  Declaration _declarationNode;
 
   ASTNode _immediateChild;
 
-  final Map<String, SimpleIdentifier> locals = new Map<String, SimpleIdentifier>();
+  Map<String, SimpleIdentifier> _locals = new Map<String, SimpleIdentifier>();
 
   int _position = 0;
 
   bool _referenceIsWithinLocalFunction = false;
 
   ScopedNameFinder(int position) {
     this._position = position;
   }
 
+  Declaration get declaration => _declarationNode;
+
+  Map<String, SimpleIdentifier> get locals => _locals;
+
   Object visitBlock(Block node) {
     checkStatements(node.statements);
     return super.visitBlock(node);
   }
 
   Object visitCatchClause(CatchClause node) {
     addToScope(node.exceptionParameter);
     addToScope(node.stackTraceParameter);
     return super.visitCatchClause(node);
   }
 
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     if (_immediateChild != node.parameters) {
       addParameters(node.parameters.parameters);
     }
-    declaration = node;
+    _declarationNode = node;
     return null;
   }
 
   Object visitFieldDeclaration(FieldDeclaration node) {
-    declaration = node;
+    _declarationNode = node;
     return null;
   }
 
   Object visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable != null) {
       addToScope(loopVariable.identifier);
     }
     return super.visitForEachStatement(node);
   }
 
   Object visitForStatement(ForStatement node) {
     if (_immediateChild != node.variables && node.variables != null) {
       addVariables(node.variables.variables);
     }
     return super.visitForStatement(node);
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     if (node.parent is! FunctionDeclarationStatement) {
-      declaration = node;
+      _declarationNode = node;
       return null;
     }
     return super.visitFunctionDeclaration(node);
   }
 
   Object visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     _referenceIsWithinLocalFunction = true;
     return super.visitFunctionDeclarationStatement(node);
   }
 
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parameters != null && _immediateChild != node.parameters) {
       addParameters(node.parameters.parameters);
     }
     return super.visitFunctionExpression(node);
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
-    declaration = node;
+    _declarationNode = node;
     if (node.parameters == null) {
       return null;
     }
     if (_immediateChild != node.parameters) {
       addParameters(node.parameters.parameters);
     }
     return null;
   }
 
   Object visitNode(ASTNode node) {
     _immediateChild = node;
     ASTNode parent = node.parent;
     if (parent != null) {
       parent.accept(this);
     }
     return null;
   }
 
   Object visitSwitchMember(SwitchMember node) {
     checkStatements(node.statements);
     return super.visitSwitchMember(node);
   }
 
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    declaration = node;
+    _declarationNode = node;
     return null;
   }
 
   Object visitTypeAlias(TypeAlias node) {
-    declaration = node;
+    _declarationNode = node;
     return null;
   }
 
   void addParameters(NodeList<FormalParameter> vars) {
     for (FormalParameter var2 in vars) {
       addToScope(var2.identifier);
     }
   }
 
   void addToScope(SimpleIdentifier identifier) {
     if (identifier != null && isInRange(identifier)) {
       String name = identifier.name;
-      if (!locals.containsKey(name)) {
-        locals[name] = identifier;
+      if (!_locals.containsKey(name)) {
+        _locals[name] = identifier;
       }
     }
   }
 
   void addVariables(NodeList<VariableDeclaration> vars) {
     for (VariableDeclaration var2 in vars) {
       addToScope(var2.name);
     }
   }
 
@@ skipping 134 matching lines @@
   }
   void operator[]=(int index, E node) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: ${index}, Size: ${_elements.length}");
     }
     owner.becomeParentOf(node);
     _elements[index] = node;
   }
   int get length => _elements.length;
 }