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);
+  AdjacentStrings(List<StringLiteral> 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);
-
   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;
 
   void visitChildren(ASTVisitor visitor) {
-    strings.accept(visitor);
+    _strings.accept(visitor);
   }
 
   void appendStringValue(JavaStringBuilder builder) {
     for (StringLiteral stringLiteral in strings) {
       stringLiteral.appendStringValue(builder);
     }
   }
 }
 
 /**
@@ skipping 13 matching lines @@
    * The annotations associated with this node.
    */
   NodeList<Annotation> _metadata;
 
   /**
    * Initialize a newly created node.
    *
    * @param comment the documentation comment associated with this node
    * @param metadata the annotations associated with this node
    */
-  AnnotatedNode.full(Comment comment, List<Annotation> metadata) {
+  AnnotatedNode(Comment comment, List<Annotation> metadata) {
     this._metadata = new NodeList<Annotation>(this);
     this._comment = becomeParentOf(comment);
     this._metadata.addAll(metadata);
   }
 
-  /**
-   * Initialize a newly created node.
-   *
-   * @param comment the documentation comment associated with this node
-   * @param metadata the annotations associated with this node
-   */
-  AnnotatedNode({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
-
   Token get beginToken {
     if (_comment == null) {
       if (_metadata.isEmpty) {
         return firstTokenAfterCommentAndMetadata;
       } else {
         return _metadata.beginToken;
       }
     } else if (_metadata.isEmpty) {
       return _comment.beginToken;
     }
@@ skipping 143 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(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
-   * @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({Token atSign, Identifier name, Token period, SimpleIdentifier constructorName, ArgumentList arguments}) : this.full(atSign, name, period, constructorName, arguments);
-
   accept(ASTVisitor visitor) => visitor.visitAnnotation(this);
 
   /**
    * Return the arguments to the constructor being invoked, or `null` if this annotation is
    * not the invocation of a constructor.
    *
    * @return the arguments to the constructor being invoked
    */
   ArgumentList get arguments => _arguments;
 
@@ skipping 104 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(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);
-
   accept(ASTVisitor visitor) => visitor.visitArgumentDefinitionTest(this);
 
   Token get beginToken => question;
 
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the identifier representing the argument being tested.
    *
    * @return the identifier representing the argument being tested
@@ skipping 33 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 11 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);
+  ArgumentList(Token leftParenthesis, List<Expression> arguments, Token rightParenthesis) {
+    this._arguments = new NodeList<Expression>(this);
     this._leftParenthesis = leftParenthesis;
-    this.arguments.addAll(arguments);
+    this._arguments.addAll(arguments);
     this._rightParenthesis = rightParenthesis;
   }
 
+  accept(ASTVisitor visitor) => visitor.visitArgumentList(this);
+
   /**
-   * Initialize a newly created list of arguments.
+   * 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.
    *
-   * @param leftParenthesis the left parenthesis
-   * @param arguments the expressions producing the values of the arguments
-   * @param rightParenthesis the right parenthesis
+   * @return the expressions producing the values of the arguments
    */
-  ArgumentList({Token leftParenthesis, List<Expression> arguments, Token rightParenthesis}) : this.full(leftParenthesis, arguments, rightParenthesis);
-
-  accept(ASTVisitor visitor) => visitor.visitArgumentList(this);
+  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 20 matching lines @@
    */
   TypeName _type;
 
   /**
    * Initialize a newly created as expression.
    *
    * @param expression the expression used to compute the value being cast
    * @param isOperator the is operator
    * @param type the name of the type being cast to
    */
-  AsExpression.full(Expression expression, Token isOperator, TypeName type) {
+  AsExpression(Expression expression, Token isOperator, TypeName type) {
     this._expression = becomeParentOf(expression);
     this.asOperator = isOperator;
     this._type = becomeParentOf(type);
   }
 
-  /**
-   * Initialize a newly created as expression.
-   *
-   * @param expression the expression used to compute the value being cast
-   * @param isOperator the is operator
-   * @param type the name of the type being cast to
-   */
-  AsExpression({Expression expression, Token isOperator, TypeName type}) : this.full(expression, isOperator, type);
-
   accept(ASTVisitor visitor) => visitor.visitAsExpression(this);
 
   Token get beginToken => _expression.beginToken;
 
   Token get endToken => _type.endToken;
 
   /**
    * Return the expression used to compute the value being cast.
    *
    * @return the expression used to compute the value being cast
@@ skipping 71 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(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
-   */
-  AssertStatement({Token keyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon}) : this.full(keyword, leftParenthesis, condition, rightParenthesis, semicolon);
-
   accept(ASTVisitor visitor) => visitor.visitAssertStatement(this);
 
   Token get beginToken => keyword;
 
   /**
    * Return the condition that is being asserted to be `true`.
    *
    * @return the condition that is being asserted to be `true`
    */
   Expression get condition => _condition;
@@ skipping 54 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(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
-   */
-  AssignmentExpression({Expression leftHandSide, Token operator, Expression rightHandSide}) : this.full(leftHandSide, operator, rightHandSide);
-
   accept(ASTVisitor visitor) => visitor.visitAssignmentExpression(this);
 
   Token get beginToken => _leftHandSide.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
@@ skipping 171 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(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
-   */
-  BinaryExpression({Expression leftOperand, Token operator, Expression rightOperand}) : this.full(leftOperand, operator, rightOperand);
-
   accept(ASTVisitor visitor) => visitor.visitBinaryExpression(this);
 
   Token get beginToken => _leftOperand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
@@ skipping 143 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(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]
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class BlockFunctionBody extends FunctionBody {
   /**
    * The block representing the body of the function.
    */
   Block _block;
 
   /**
    * Initialize a newly created function body consisting of a block of statements.
    *
    * @param block the block representing the body of the function
    */
-  BlockFunctionBody.full(Block block) {
+  BlockFunctionBody(Block block) {
     this._block = becomeParentOf(block);
   }
 
-  /**
-   * Initialize a newly created function body consisting of a block of statements.
-   *
-   * @param block the block representing the body of the function
-   */
-  BlockFunctionBody({Block block}) : this.full(block);
-
   accept(ASTVisitor visitor) => visitor.visitBlockFunctionBody(this);
 
   Token get beginToken => _block.beginToken;
 
   /**
    * Return the block representing the body of the function.
    *
    * @return the block representing the body of the function
    */
   Block get block => _block;
@@ skipping 34 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;
-  }
-
-  /**
-   * 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);
+  BooleanLiteral(this.literal, this.value);
 
   accept(ASTVisitor visitor) => visitor.visitBooleanLiteral(this);
 
   Token get beginToken => literal;
 
   Token get endToken => literal;
 
   bool get isSynthetic => literal.isSynthetic;
 
   void visitChildren(ASTVisitor visitor) {
@@ skipping 26 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(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);
-
   accept(ASTVisitor visitor) => visitor.visitBreakStatement(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => semicolon;
 
   /**
    * Return the label associated with the statement, or `null` if there is no label.
    *
    * @return the label associated with the statement
@@ skipping 36 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);
+  CascadeExpression(Expression target, List<Expression> cascadeSections) {
+    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(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
-   * @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({Token onKeyword, TypeName exceptionType, Token catchKeyword, Token leftParenthesis, SimpleIdentifier exceptionParameter, Token comma, SimpleIdentifier stackTraceParameter, Token rightParenthesis, Block body}) : this.full(onKeyword, exceptionType, catchKeyword, leftParenthesis, exceptionParameter, comma, stackTraceParameter, rightParenthesis, body);
-
   accept(ASTVisitor visitor) => visitor.visitCatchClause(this);
 
   Token get beginToken {
     if (onKeyword != null) {
       return onKeyword;
     }
     return catchKeyword;
   }
 
   /**
@@ skipping 146 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(Comment comment, List<Annotation> metadata, this.abstractKeyword, this.classKeyword, SimpleIdentifier name, TypeParameterList typeParameters, ExtendsClause extendsClause, WithClause withClause, ImplementsClause implementsClause, this.leftBracket, List<ClassMember> members, this.rightBracket) : super(comment, metadata) {
+    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
-   * @param typeParameters the type parameters for the class
-   * @param extendsClause the extends clause for the class
-   * @param withClause the with clause for the class
-   * @param implementsClause the implements clause for the class
-   * @param leftBracket the left curly bracket
-   * @param members the members defined by the class
-   * @param rightBracket the right curly bracket
-   */
-  ClassDeclaration({Comment comment, List<Annotation> metadata, Token abstractKeyword, Token classKeyword, SimpleIdentifier name, TypeParameterList typeParameters, ExtendsClause extendsClause, WithClause withClause, ImplementsClause implementsClause, Token leftBracket, List<ClassMember> members, Token rightBracket}) : this.full(comment, metadata, abstractKeyword, classKeyword, name, typeParameters, extendsClause, withClause, implementsClause, leftBracket, members, rightBracket);
-
   accept(ASTVisitor visitor) => visitor.visitClassDeclaration(this);
 
   ClassElement get element => _name != null ? (_name.staticElement as ClassElement) : null;
 
   Token get endToken => rightBracket;
 
   /**
    * Return the extends clause for this class, or `null` if the class does not extend any
    * other class.
    *
    * @return the extends clause for this class
    */
   ExtendsClause get extendsClause => _extendsClause;
 
   /**
+   * Return the field declared in the class with the given name.
+   *
+   * @param name the name of the field to find
+   * @return the found field or `null` if not found
+   */
+  VariableDeclaration getField(String name) {
+    for (ClassMember classMember in _members) {
+      if (classMember is FieldDeclaration) {
+        FieldDeclaration fieldDeclaration = classMember as FieldDeclaration;
+        NodeList<VariableDeclaration> fields = fieldDeclaration.fields.variables;
+        for (VariableDeclaration field in fields) {
+          SimpleIdentifier fieldName = field.name;
+          if (fieldName != null && name == fieldName.name) {
+            return field;
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
    * 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 61 matching lines @@
  *
  * @coverage dart.engine.ast
  */
 abstract class ClassMember extends Declaration {
   /**
    * Initialize a newly created member of a class.
    *
    * @param comment the documentation comment associated with this member
    * @param metadata the annotations associated with this member
    */
-  ClassMember.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata);
-
-  /**
-   * Initialize a newly created member of a class.
-   *
-   * @param comment the documentation comment associated with this member
-   * @param metadata the annotations associated with this member
-   */
-  ClassMember({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
+  ClassMember(Comment comment, List<Annotation> metadata) : super(comment, metadata);
 }
 
 /**
  * Instances of the class `ClassTypeAlias` represent a class type alias.
  *
  * <pre>
  * classTypeAlias ::=
  *     [SimpleIdentifier] [TypeParameterList]? '=' 'abstract'? mixinApplication
  *
  * mixinApplication ::=
@@ skipping 48 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(Comment comment, List<Annotation> metadata, Token keyword, SimpleIdentifier name, TypeParameterList typeParameters, this.equals, this.abstractKeyword, TypeName superclass, WithClause withClause, ImplementsClause implementsClause, Token semicolon) : super(comment, metadata, keyword, semicolon) {
     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
-   * @param keyword the token representing the 'typedef' keyword
-   * @param name the name of the class being declared
-   * @param typeParameters the type parameters for the class
-   * @param equals the token for the '=' separating the name from the definition
-   * @param abstractKeyword the token for the 'abstract' keyword
-   * @param superclass the name of the superclass of the class being declared
-   * @param withClause the with clause for this class
-   * @param implementsClause the implements clause for this class
-   * @param semicolon the semicolon terminating the declaration
-   */
-  ClassTypeAlias({Comment comment, List<Annotation> metadata, Token keyword, SimpleIdentifier name, TypeParameterList typeParameters, Token equals, Token abstractKeyword, TypeName superclass, WithClause withClause, ImplementsClause implementsClause, Token semicolon}) : this.full(comment, metadata, keyword, name, typeParameters, equals, abstractKeyword, superclass, withClause, implementsClause, semicolon);
-
   accept(ASTVisitor visitor) => visitor.visitClassTypeAlias(this);
 
   ClassElement get element => _name != null ? (_name.staticElement as ClassElement) : null;
 
   /**
    * Return the implements clause for this class, or `null` if there is no implements clause.
    *
    * @return the implements clause for this class
    */
   ImplementsClause get implementsClause => _implementsClause;
@@ skipping 99 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;
-  }
-
-  /**
-   * 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);
+  Combinator(this.keyword);
 
   Token get beginToken => keyword;
 }
 
 /**
  * Instances of the class `Comment` represent a comment within the source code.
  *
  * <pre>
  * comment ::=
  *     endOfLineComment
@@ skipping 13 matching lines @@
  *
  * @coverage dart.engine.ast
  */
 class Comment extends ASTNode {
   /**
    * Create a block comment.
    *
    * @param tokens the tokens representing the comment
    * @return the block comment that was created
    */
-  static Comment createBlockComment(List<Token> tokens) => new Comment.full(tokens, CommentType.BLOCK, null);
+  static Comment createBlockComment(List<Token> tokens) => new Comment(tokens, CommentType.BLOCK, null);
 
   /**
    * Create a documentation comment.
    *
    * @param tokens the tokens representing the comment
    * @return the documentation comment that was created
    */
-  static Comment createDocumentationComment(List<Token> tokens) => new Comment.full(tokens, CommentType.DOCUMENTATION, new List<CommentReference>());
+  static Comment createDocumentationComment(List<Token> tokens) => new Comment(tokens, CommentType.DOCUMENTATION, new List<CommentReference>());
 
   /**
    * Create a documentation comment.
    *
    * @param tokens the tokens representing the comment
    * @param references the references embedded within the documentation comment
    * @return the documentation comment that was created
    */
-  static Comment createDocumentationComment2(List<Token> tokens, List<CommentReference> references) => new Comment.full(tokens, CommentType.DOCUMENTATION, references);
+  static Comment createDocumentationComment2(List<Token> tokens, List<CommentReference> references) => new Comment(tokens, CommentType.DOCUMENTATION, references);
 
   /**
    * 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);
+  static Comment createEndOfLineComment(List<Token> tokens) => new Comment(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(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(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);
-
   accept(ASTVisitor visitor) => visitor.visitCommentReference(this);
 
   Token get beginToken => _identifier.beginToken;
 
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the identifier being referenced.
    *
    * @return the identifier being referenced
@@ skipping 37 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(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.
  *
  * <pre>
  * compilationUnitMember ::=
  *     [ClassDeclaration]
  *   | [TypeAlias]
  *   | [FunctionDeclaration]
  *   | [MethodDeclaration]
  *   | [VariableDeclaration]
  *   | [VariableDeclaration]
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 abstract class CompilationUnitMember extends Declaration {
   /**
    * Initialize a newly created generic compilation unit member.
    *
    * @param comment the documentation comment associated with this member
    * @param metadata the annotations associated with this member
    */
-  CompilationUnitMember.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata);
-
-  /**
-   * Initialize a newly created generic compilation unit member.
-   *
-   * @param comment the documentation comment associated with this member
-   * @param metadata the annotations associated with this member
-   */
-  CompilationUnitMember({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
+  CompilationUnitMember(Comment comment, List<Annotation> metadata) : super(comment, metadata);
 }
 
 /**
  * Instances of the class `ConditionalExpression` represent a conditional expression.
  *
  * <pre>
  * conditionalExpression ::=
  *     [Expression] '?' [Expression] ':' [Expression]
  * </pre>
  *
@@ skipping 29 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(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`
-   * @param colon the token used to separate the then expression from the else expression
-   * @param elseExpression the expression that is executed if the condition evaluates to
-   *          `false`
-   */
-  ConditionalExpression({Expression condition, Token question, Expression thenExpression, Token colon, Expression elseExpression}) : this.full(condition, question, thenExpression, colon, elseExpression);
-
   accept(ASTVisitor visitor) => visitor.visitConditionalExpression(this);
 
   Token get beginToken => _condition.beginToken;
 
   /**
    * Return the condition used to determine which of the expressions is executed next.
    *
    * @return the condition used to determine which expression is executed next
    */
   Expression get condition => _condition;
@@ skipping 120 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(Comment comment, List<Annotation> metadata, this.externalKeyword, this.constKeyword, this.factoryKeyword, Identifier returnType, this.period, SimpleIdentifier name, FormalParameterList parameters, this.separator, List<ConstructorInitializer> initializers, ConstructorName redirectedConstructor, FunctionBody body) : super(comment, metadata) {
+    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
-   * @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({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}) : this.full(comment, metadata, externalKeyword, constKeyword, factoryKeyword, returnType, period, name, parameters, separator, initializers, redirectedConstructor, body);
-
   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(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
-   * @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({Token keyword, Token period, SimpleIdentifier fieldName, Token equals, Expression expression}) : this.full(keyword, period, fieldName, equals, expression);
-
   accept(ASTVisitor visitor) => visitor.visitConstructorFieldInitializer(this);
 
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     }
     return _fieldName.beginToken;
   }
 
   Token get endToken => _expression.endToken;
@@ skipping 87 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(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
-   */
-  ConstructorName({TypeName type, Token period, SimpleIdentifier name}) : this.full(type, period, name);
-
   accept(ASTVisitor visitor) => visitor.visitConstructorName(this);
 
   Token get beginToken => _type.beginToken;
 
   Token get endToken {
     if (_name != null) {
       return _name.endToken;
     }
     return _type.endToken;
   }
@@ skipping 82 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(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);
-
   accept(ASTVisitor visitor) => visitor.visitContinueStatement(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => semicolon;
 
   /**
    * Return the label associated with the statement, or `null` if there is no label.
    *
    * @return the label associated with the statement
@@ skipping 20 matching lines @@
  *
  * @coverage dart.engine.ast
  */
 abstract class Declaration extends AnnotatedNode {
   /**
    * Initialize a newly created declaration.
    *
    * @param comment the documentation comment associated with this declaration
    * @param metadata the annotations associated with this declaration
    */
-  Declaration.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata);
-
-  /**
-   * Initialize a newly created declaration.
-   *
-   * @param comment the documentation comment associated with this declaration
-   * @param metadata the annotations associated with this declaration
-   */
-  Declaration({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
+  Declaration(Comment comment, List<Annotation> metadata) : super(comment, metadata);
 
   /**
    * Return the element associated with this declaration, or `null` if either this node
    * corresponds to a list of declarations or if the AST structure has not been resolved.
    *
    * @return the element associated with this declaration
    */
   Element get element;
 }
 
@@ skipping 17 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(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, SimpleIdentifier identifier) : super(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(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
-   */
-  DefaultFormalParameter({NormalFormalParameter parameter, ParameterKind kind, Token separator, Expression defaultValue}) : this.full(parameter, kind, separator, defaultValue);
-
   accept(ASTVisitor visitor) => visitor.visitDefaultFormalParameter(this);
 
   Token get beginToken => _parameter.beginToken;
 
   /**
    * Return the expression computing the default value for the parameter, or `null` if there
    * is no default value.
    *
    * @return the expression computing the default value for the parameter
    */
   Expression get defaultValue => _defaultValue;
 
   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 22 matching lines @@
    * resolved or if this directive could not be resolved.
    */
   Element _element;
 
   /**
    * Initialize a newly create directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    */
-  Directive.full(Comment comment, List<Annotation> metadata) : super.full(comment, metadata);
-
-  /**
-   * Initialize a newly create directive.
-   *
-   * @param comment the documentation comment associated with this directive
-   * @param metadata the annotations associated with the directive
-   */
-  Directive({Comment comment, List<Annotation> metadata}) : this.full(comment, metadata);
+  Directive(Comment comment, List<Annotation> metadata) : super(comment, metadata);
 
   /**
    * Return the element associated with this directive, or `null` if the AST structure has not
    * been resolved or if this directive could not be resolved. Examples of the latter case include a
    * directive that contains an invalid URL or a URL that does not exist.
    *
    * @return the element associated with this directive
    */
   Element get element => _element;
 
@@ skipping 65 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(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
-   * @param rightParenthesis the right parenthesis
-   * @param semicolon the semicolon terminating the statement
-   */
-  DoStatement({Token doKeyword, Statement body, Token whileKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon}) : this.full(doKeyword, body, whileKeyword, leftParenthesis, condition, rightParenthesis, semicolon);
-
   accept(ASTVisitor visitor) => visitor.visitDoStatement(this);
 
   Token get beginToken => doKeyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
@@ skipping 87 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;
-  }
-
-  /**
-   * 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);
+  DoubleLiteral(this.literal, this.value);
 
   accept(ASTVisitor visitor) => visitor.visitDoubleLiteral(this);
 
   Token get beginToken => literal;
 
   Token get endToken => literal;
 
   void visitChildren(ASTVisitor visitor) {
   }
 }
@@ skipping 13 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;
-  }
-
-  /**
-   * 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);
+  EmptyFunctionBody(this.semicolon);
 
   accept(ASTVisitor visitor) => visitor.visitEmptyFunctionBody(this);
 
   Token get beginToken => semicolon;
 
   Token get endToken => semicolon;
 
   void visitChildren(ASTVisitor visitor) {
   }
 }
@@ skipping 12 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;
-  }
-
-  /**
-   * Initialize a newly created empty statement.
-   *
-   * @param semicolon the semicolon terminating the statement
-   */
-  EmptyStatement({Token semicolon}) : this.full(semicolon);
+  EmptyStatement(this.semicolon);
 
   accept(ASTVisitor visitor) => visitor.visitEmptyStatement(this);
 
   Token get beginToken => semicolon;
 
   Token get endToken => semicolon;
 
   void visitChildren(ASTVisitor visitor) {
   }
 }
 
 /**
  * Ephemeral identifiers are created as needed to mimic the presence of an empty identifier.
  *
  * @coverage dart.engine.ast
  */
 class EphemeralIdentifier extends SimpleIdentifier {
-  EphemeralIdentifier.full(ASTNode parent, int location) : super.full(new StringToken(TokenType.IDENTIFIER, "", location)) {
+  EphemeralIdentifier(ASTNode parent, int location) : super(new StringToken(TokenType.IDENTIFIER, "", location)) {
     parent.becomeParentOf(this);
   }
-
-  EphemeralIdentifier({ASTNode parent, int location}) : this.full(parent, location);
 }
 
 /**
  * Instances of the class `ExportDirective` represent an export directive.
  *
  * <pre>
  * exportDirective ::=
  *     [Annotation] 'export' [StringLiteral] [Combinator]* ';'
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class ExportDirective extends NamespaceDirective {
   /**
    * Initialize a newly created export directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param keyword the token representing the 'export' keyword
    * @param libraryUri the URI of the library being exported
    * @param combinators the combinators used to control which names are exported
    * @param semicolon the semicolon terminating the directive
    */
-  ExportDirective.full(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon) : super.full(comment, metadata, keyword, libraryUri, combinators, semicolon);
-
-  /**
-   * Initialize a newly created export directive.
-   *
-   * @param comment the documentation comment associated with this directive
-   * @param metadata the annotations associated with the directive
-   * @param keyword the token representing the 'export' keyword
-   * @param libraryUri the URI of the library being exported
-   * @param combinators the combinators used to control which names are exported
-   * @param semicolon the semicolon terminating the directive
-   */
-  ExportDirective({Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon}) : this.full(comment, metadata, keyword, libraryUri, combinators, semicolon);
+  ExportDirective(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon) : super(comment, metadata, keyword, libraryUri, combinators, semicolon);
 
   accept(ASTVisitor visitor) => visitor.visitExportDirective(this);
 
   LibraryElement get uriElement {
     Element element = this.element;
     if (element is ExportElement) {
       return (element as ExportElement).exportedLibrary;
     }
     return null;
   }
@@ skipping 186 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(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
-   */
-  ExpressionFunctionBody({Token functionDefinition, Expression expression, Token semicolon}) : this.full(functionDefinition, expression, semicolon);
-
   accept(ASTVisitor visitor) => visitor.visitExpressionFunctionBody(this);
 
   Token get beginToken => functionDefinition;
 
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
@@ skipping 40 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(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);
-
   accept(ASTVisitor visitor) => visitor.visitExpressionStatement(this);
 
   Token get beginToken => _expression.beginToken;
 
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
@@ skipping 42 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(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);
-
   accept(ASTVisitor visitor) => visitor.visitExtendsClause(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => _superclass.endToken;
 
   /**
    * Return the name of the class that is being extended.
    *
    * @return the name of the class that is being extended
@@ skipping 43 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(Comment comment, List<Annotation> metadata, this.staticKeyword, VariableDeclarationList fieldList, this.semicolon) : super(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
-   */
-  FieldDeclaration({Comment comment, List<Annotation> metadata, Token staticKeyword, VariableDeclarationList fieldList, Token semicolon}) : this.full(comment, metadata, staticKeyword, fieldList, semicolon);
-
   accept(ASTVisitor visitor) => visitor.visitFieldDeclaration(this);
 
   Element get element => null;
 
   Token get endToken => semicolon;
 
   /**
    * Return the fields being declared.
    *
    * @return the fields being declared
@@ skipping 74 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(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, this.thisToken, this.period, SimpleIdentifier identifier, FormalParameterList parameters) : super(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
-   * @param thisToken the token representing the 'this' keyword
-   * @param period the token representing the period
-   * @param identifier the name of the parameter being declared
-   * @param parameters the parameters of the function-typed parameter, or `null` if this is
-   *          not a function-typed field formal parameter
-   */
-  FieldFormalParameter({Comment comment, List<Annotation> metadata, Token keyword, TypeName type, Token thisToken, Token period, SimpleIdentifier identifier, FormalParameterList parameters}) : this.full(comment, metadata, keyword, type, thisToken, period, identifier, parameters);
-
   accept(ASTVisitor visitor) => visitor.visitFieldFormalParameter(this);
 
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return thisToken;
   }
@@ skipping 103 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(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(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
-   * @param rightParenthesis the right parenthesis
-   * @param body the body of the loop
-   */
-  ForEachStatement.con2({Token forKeyword, Token leftParenthesis, SimpleIdentifier identifier, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body}) : this.con2_full(forKeyword, leftParenthesis, identifier, inKeyword, iterator, rightParenthesis, body);
-
   accept(ASTVisitor visitor) => visitor.visitForEachStatement(this);
 
   Token get beginToken => forKeyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
@@ skipping 120 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(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
-   * @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({Token forKeyword, Token leftParenthesis, VariableDeclarationList variableList, Expression initialization, Token leftSeparator, Expression condition, Token rightSeparator, List<Expression> updaters, Token rightParenthesis, Statement body}) : this.full(forKeyword, leftParenthesis, variableList, initialization, leftSeparator, condition, rightSeparator, updaters, rightParenthesis, body);
-
   accept(ASTVisitor visitor) => visitor.visitForStatement(this);
 
   Token get beginToken => forKeyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
 
   /**
    * Return the condition used to determine when to terminate the loop, or `null` if there is
    * no condition.
    *
    * @return the condition used to determine when to terminate the loop
    */
   Expression get condition => _condition;
 
   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);
+  FormalParameterList(Token leftParenthesis, List<FormalParameter> parameters, Token leftDelimiter, Token rightDelimiter, Token rightParenthesis) {
+    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
-   * @param leftDelimiter the left delimiter introducing the optional parameters
-   * @param rightDelimiter the right delimiter introducing the optional parameters
-   * @param rightParenthesis the right parenthesis
-   */
-  FormalParameterList({Token leftParenthesis, List<FormalParameter> parameters, Token leftDelimiter, Token rightDelimiter, Token rightParenthesis}) : this.full(leftParenthesis, parameters, leftDelimiter, rightDelimiter, rightParenthesis);
-
   accept(ASTVisitor visitor) => visitor.visitFormalParameterList(this);
 
   Token get beginToken => _leftParenthesis;
 
   Token get endToken => _rightParenthesis;
 
   /**
    * Return the left square bracket ('[') or left curly brace ('{') introducing the optional
    * parameters, or `null` if there are no optional parameters.
    *
    * @return the left square bracket ('[') or left curly brace ('{') introducing the optional
    *         parameters
    */
   Token get leftDelimiter => _leftDelimiter;
 
   /**
    * Return the left parenthesis.
    *
    * @return the left parenthesis
    */
   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(Comment comment, List<Annotation> metadata, this.externalKeyword, TypeName returnType, this.propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression) : super(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
-   * @param returnType the return type of the function
-   * @param propertyKeyword the token representing the 'get' or 'set' keyword
-   * @param name the name of the function
-   * @param functionExpression the function expression being wrapped
-   */
-  FunctionDeclaration({Comment comment, List<Annotation> metadata, Token externalKeyword, TypeName returnType, Token propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression}) : this.full(comment, metadata, externalKeyword, returnType, propertyKeyword, name, functionExpression);
-
   accept(ASTVisitor visitor) => visitor.visitFunctionDeclaration(this);
 
   ExecutableElement get element => _name != null ? (_name.staticElement as ExecutableElement) : null;
 
   Token get endToken => _functionExpression.endToken;
 
   /**
    * Return the function expression being wrapped.
    *
    * @return the function expression being wrapped
@@ skipping 80 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);
+  FunctionDeclarationStatement(FunctionDeclaration 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 16 matching lines @@
    * resolved.
    */
   ExecutableElement element;
 
   /**
    * Initialize a newly created function declaration.
    *
    * @param parameters the parameters associated with the function
    * @param body the body of the function
    */
-  FunctionExpression.full(FormalParameterList parameters, FunctionBody body) {
+  FunctionExpression(FormalParameterList parameters, FunctionBody body) {
     this._parameters = becomeParentOf(parameters);
     this._body = becomeParentOf(body);
   }
 
-  /**
-   * Initialize a newly created function declaration.
-   *
-   * @param parameters the parameters associated with the function
-   * @param body the body of the function
-   */
-  FunctionExpression({FormalParameterList parameters, FunctionBody body}) : this.full(parameters, body);
-
   accept(ASTVisitor visitor) => visitor.visitFunctionExpression(this);
 
   Token get beginToken {
     if (_parameters != null) {
       return _parameters.beginToken;
     } else if (_body != null) {
       return _body.beginToken;
     }
     throw new IllegalStateException("Non-external functions must have a body");
   }
@@ skipping 83 matching lines @@
    * `null` if the AST structure has not been resolved or the function could not be resolved.
    */
   ExecutableElement _propagatedElement;
 
   /**
    * Initialize a newly created function expression invocation.
    *
    * @param function the expression producing the function being invoked
    * @param argumentList the list of arguments to the method
    */
-  FunctionExpressionInvocation.full(Expression function, ArgumentList argumentList) {
+  FunctionExpressionInvocation(Expression function, ArgumentList argumentList) {
     this._function = becomeParentOf(function);
     this._argumentList = becomeParentOf(argumentList);
   }
 
-  /**
-   * Initialize a newly created function expression invocation.
-   *
-   * @param function the expression producing the function being invoked
-   * @param argumentList the list of arguments to the method
-   */
-  FunctionExpressionInvocation({Expression function, ArgumentList argumentList}) : this.full(function, argumentList);
-
   accept(ASTVisitor visitor) => visitor.visitFunctionExpressionInvocation(this);
 
   /**
    * Return the list of arguments to the method.
    *
    * @return the list of arguments to the method
    */
   ArgumentList get argumentList => _argumentList;
 
   Token get beginToken => _function.beginToken;
@@ skipping 110 matching lines @@
    *
    * @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 returnType the name of the return type of the function type being defined
    * @param name the name of the type being declared
    * @param typeParameters the type parameters for the type
    * @param parameters the parameters associated with the function
    * @param semicolon the semicolon terminating the declaration
    */
-  FunctionTypeAlias.full(Comment comment, List<Annotation> metadata, Token keyword, TypeName returnType, SimpleIdentifier name, TypeParameterList typeParameters, FormalParameterList parameters, Token semicolon) : super.full(comment, metadata, keyword, semicolon) {
+  FunctionTypeAlias(Comment comment, List<Annotation> metadata, Token keyword, TypeName returnType, SimpleIdentifier name, TypeParameterList typeParameters, FormalParameterList parameters, Token semicolon) : super(comment, metadata, keyword, semicolon) {
     this._returnType = becomeParentOf(returnType);
     this._name = becomeParentOf(name);
     this._typeParameters = becomeParentOf(typeParameters);
     this._parameters = becomeParentOf(parameters);
   }
 
-  /**
-   * Initialize a newly created function 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 returnType the name of the return type of the function type being defined
-   * @param name the name of the type being declared
-   * @param typeParameters the type parameters for the type
-   * @param parameters the parameters associated with the function
-   * @param semicolon the semicolon terminating the declaration
-   */
-  FunctionTypeAlias({Comment comment, List<Annotation> metadata, Token keyword, TypeName returnType, SimpleIdentifier name, TypeParameterList typeParameters, FormalParameterList parameters, Token semicolon}) : this.full(comment, metadata, keyword, returnType, name, typeParameters, parameters, semicolon);
-
   accept(ASTVisitor visitor) => visitor.visitFunctionTypeAlias(this);
 
   FunctionTypeAliasElement get element => _name != null ? (_name.staticElement as FunctionTypeAliasElement) : null;
 
   /**
    * Return the name of the function type being declared.
    *
    * @return the name of the function type being declared
    */
   SimpleIdentifier get name => _name;
@@ skipping 91 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 returnType the return type of the function, or `null` if the function does not
    *          have a return type
    * @param identifier the name of the function-typed parameter
    * @param parameters the parameters of the function-typed parameter
    */
-  FunctionTypedFormalParameter.full(Comment comment, List<Annotation> metadata, TypeName returnType, SimpleIdentifier identifier, FormalParameterList parameters) : super.full(comment, metadata, identifier) {
+  FunctionTypedFormalParameter(Comment comment, List<Annotation> metadata, TypeName returnType, SimpleIdentifier identifier, FormalParameterList parameters) : super(comment, metadata, identifier) {
     this._returnType = becomeParentOf(returnType);
     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 returnType the return type of the function, or `null` if the function does not
-   *          have a return type
-   * @param identifier the name of the function-typed parameter
-   * @param parameters the parameters of the function-typed parameter
-   */
-  FunctionTypedFormalParameter({Comment comment, List<Annotation> metadata, TypeName returnType, SimpleIdentifier identifier, FormalParameterList parameters}) : this.full(comment, metadata, returnType, identifier, parameters);
-
   accept(ASTVisitor visitor) => visitor.visitFunctionTypedFormalParameter(this);
 
   Token get beginToken {
     if (_returnType != null) {
       return _returnType.beginToken;
     }
     return identifier.beginToken;
   }
 
   Token get endToken => _parameters.endToken;
@@ skipping 51 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);
+  HideCombinator(Token keyword, List<SimpleIdentifier> hiddenNames) : super(keyword) {
+    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(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
-   * @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({Token ifKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Statement thenStatement, Token elseKeyword, Statement elseStatement}) : this.full(ifKeyword, leftParenthesis, condition, rightParenthesis, thenStatement, elseKeyword, elseStatement);
-
   accept(ASTVisitor visitor) => visitor.visitIfStatement(this);
 
   Token get beginToken => ifKeyword;
 
   /**
    * Return the condition used to determine which of the statements is executed next.
    *
    * @return the condition used to determine which statement is executed next
    */
   Expression get condition => _condition;
@@ skipping 70 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(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(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, this.asToken, SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon) : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
     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
-   * @param asToken the token representing the 'as' token
-   * @param prefix the prefix to be used with the imported names
-   * @param combinators the combinators used to control how names are imported
-   * @param semicolon the semicolon terminating the directive
-   */
-  ImportDirective({Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, Token asToken, SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon}) : this.full(comment, metadata, keyword, libraryUri, asToken, prefix, combinators, semicolon);
-
   accept(ASTVisitor visitor) => visitor.visitImportDirective(this);
 
   ImportElement get element => super.element as ImportElement;
 
   /**
    * Return the prefix to be used with the imported names, or `null` if the imported names are
    * not prefixed.
    *
    * @return the prefix to be used with the imported names
    */
@@ skipping 83 matching lines @@
   AuxiliaryElements auxiliaryElements = null;
 
   /**
    * Initialize a newly created index expression.
    *
    * @param target the expression used to compute the object being indexed
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
-  IndexExpression.forTarget_full(Expression target, Token leftBracket, Expression index, Token rightBracket) {
+  IndexExpression.forTarget(Expression target, Token leftBracket, Expression index, Token rightBracket) {
     this._target = becomeParentOf(target);
     this._leftBracket = leftBracket;
     this._index = becomeParentOf(index);
     this._rightBracket = rightBracket;
   }
 
   /**
    * Initialize a newly created index expression.
    *
-   * @param target the expression used to compute the object being indexed
-   * @param leftBracket the left square bracket
-   * @param index the expression used to compute the index
-   * @param rightBracket the right square bracket
-   */
-  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(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
-   * @param index the expression used to compute the index
-   * @param rightBracket the right square bracket
-   */
-  IndexExpression.forCascade({Token period, Token leftBracket, Expression index, Token rightBracket}) : this.forCascade_full(period, leftBracket, index, rightBracket);
-
   accept(ASTVisitor visitor) => visitor.visitIndexExpression(this);
 
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return period;
   }
 
   /**
@@ skipping 279 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(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
-   */
-  InstanceCreationExpression({Token keyword, ConstructorName constructorName, ArgumentList argumentList}) : this.full(keyword, constructorName, argumentList);
-
   accept(ASTVisitor visitor) => visitor.visitInstanceCreationExpression(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
    * @return the list of arguments to the constructor
    */
   ArgumentList get argumentList => _argumentList;
 
   Token get beginToken => keyword;
@@ skipping 52 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;
-  }
-
-  /**
-   * 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);
+  IntegerLiteral(this.literal, this.value);
 
   accept(ASTVisitor visitor) => visitor.visitIntegerLiteral(this);
 
   Token get beginToken => literal;
 
   Token get endToken => literal;
 
   void visitChildren(ASTVisitor visitor) {
   }
 }
@@ skipping 42 matching lines @@
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created interpolation expression.
    *
    * @param leftBracket the left curly bracket
    * @param expression the expression to be evaluated for the value to be converted into a string
    * @param rightBracket the right curly bracket
    */
-  InterpolationExpression.full(Token leftBracket, Expression expression, Token rightBracket) {
-    this.leftBracket = leftBracket;
+  InterpolationExpression(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);
-
   accept(ASTVisitor visitor) => visitor.visitInterpolationExpression(this);
 
   Token get beginToken => leftBracket;
 
   Token get endToken {
     if (rightBracket != null) {
       return rightBracket;
     }
     return _expression.endToken;
   }
@@ skipping 41 matching lines @@
    * The value of the literal.
    */
   String _value;
 
   /**
    * Initialize a newly created string of characters that are part of a string interpolation.
    *
    * @param the characters that will be added to the string
    * @param value the value of the literal
    */
-  InterpolationString.full(Token contents, String value) {
+  InterpolationString(Token contents, String value) {
     this._contents = contents;
     this._value = value;
   }
 
-  /**
-   * Initialize a newly created string of characters that are part of a string interpolation.
-   *
-   * @param the characters that will be added to the string
-   * @param value the value of the literal
-   */
-  InterpolationString({Token contents, String value}) : this.full(contents, value);
-
   accept(ASTVisitor visitor) => visitor.visitInterpolationString(this);
 
   Token get beginToken => _contents;
 
   /**
    * Return the characters that will be added to the string.
    *
    * @return the characters that will be added to the string
    */
   Token get contents => _contents;
@@ skipping 61 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(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
-   */
-  IsExpression({Expression expression, Token isOperator, Token notOperator, TypeName type}) : this.full(expression, isOperator, notOperator, type);
-
   accept(ASTVisitor visitor) => visitor.visitIsExpression(this);
 
   Token get beginToken => _expression.beginToken;
 
   Token get endToken => _type.endToken;
 
   /**
    * Return the expression used to compute the value whose type is being tested.
    *
    * @return the expression used to compute the value whose type is being tested
@@ skipping 54 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(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);
-
   accept(ASTVisitor visitor) => visitor.visitLabel(this);
 
   Token get beginToken => _label.beginToken;
 
   Token get endToken => colon;
 
   /**
    * Return the label being associated with the statement.
    *
    * @return the label being associated with the statement
@@ skipping 22 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);
+  LabeledStatement(List<Label> labels, Statement statement) {
+    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(Comment comment, List<Annotation> metadata, this.libraryToken, LibraryIdentifier name, this.semicolon) : super(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
-   */
-  LibraryDirective({Comment comment, List<Annotation> metadata, Token libraryToken, LibraryIdentifier name, Token semicolon}) : this.full(comment, metadata, libraryToken, name, semicolon);
-
   accept(ASTVisitor visitor) => visitor.visitLibraryDirective(this);
 
   Token get endToken => semicolon;
 
   Token get keyword => libraryToken;
 
   /**
    * Return the name of the library being defined.
    *
    * @return the name of the library being defined
@@ skipping 24 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);
+  LibraryIdentifier(List<SimpleIdentifier> 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._leftBracket = leftBracket;
-    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);
+  ListLiteral(Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket) : super(constKeyword, typeArguments) {
+    this._elements = new NodeList<Expression>(this);
+    this._leftBracket = leftBracket;
+    this._elements.addAll(elements);
+    this._rightBracket = 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);
+  MapLiteral(Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket) : super(constKeyword, typeArguments) {
+    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
-   * @param entries the entries in the map
-   * @param rightBracket the right curly bracket
-   */
-  MapLiteral({Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket}) : this.full(constKeyword, typeArguments, leftBracket, entries, rightBracket);
-
   accept(ASTVisitor visitor) => visitor.visitMapLiteral(this);
 
   Token get beginToken {
     Token token = constKeyword;
     if (token != null) {
       return token;
     }
     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(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
-   */
-  MapLiteralEntry({Expression key, Token separator, Expression value}) : this.full(key, separator, value);
-
   accept(ASTVisitor visitor) => visitor.visitMapLiteralEntry(this);
 
   Token get beginToken => _key.beginToken;
 
   Token get endToken => _value.endToken;
 
   /**
    * Return the expression computing the key with which the value will be associated.
    *
    * @return the expression computing the key with which the value will be associated
@@ skipping 103 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(Comment comment, List<Annotation> metadata, this.externalKeyword, this.modifierKeyword, TypeName returnType, this.propertyKeyword, this.operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body) : super(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
-   * @param metadata the annotations associated with this method
-   * @param modifierKeyword the token representing the 'abstract' or 'static' keyword
-   * @param returnType the return type of the method
-   * @param propertyKeyword the token representing the 'get' or 'set' keyword
-   * @param operatorKeyword the token representing the 'operator' keyword
-   * @param name the name of the method
-   * @param parameters the parameters associated with the method, or `null` if this method
-   *          declares a getter
-   * @param body the body of the method
-   */
-  MethodDeclaration({Comment comment, List<Annotation> metadata, Token externalKeyword, Token modifierKeyword, TypeName returnType, Token propertyKeyword, Token operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body}) : this.full(comment, metadata, externalKeyword, modifierKeyword, returnType, propertyKeyword, operatorKeyword, name, parameters, body);
-
   accept(ASTVisitor visitor) => visitor.visitMethodDeclaration(this);
 
   /**
    * Return the body of the method.
    *
    * @return the body of the method
    */
   FunctionBody get body => _body;
 
   /**
@@ skipping 161 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(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
-   * @param argumentList the list of arguments to the method
-   */
-  MethodInvocation({Expression target, Token period, SimpleIdentifier methodName, ArgumentList argumentList}) : this.full(target, period, methodName, argumentList);
-
   accept(ASTVisitor visitor) => visitor.visitMethodInvocation(this);
 
   /**
    * Return the list of arguments to the method.
    *
    * @return the list of arguments to the method
    */
   ArgumentList get argumentList => _argumentList;
 
   Token get beginToken {
@@ skipping 113 matching lines @@
    * The expression with which the name is associated.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created named expression.
    *
    * @param name the name associated with the expression
    * @param expression the expression with which the name is associated
    */
-  NamedExpression.full(Label name, Expression expression) {
+  NamedExpression(Label name, Expression expression) {
     this._name = becomeParentOf(name);
     this._expression = becomeParentOf(expression);
   }
 
-  /**
-   * Initialize a newly created named expression.
-   *
-   * @param name the name associated with the expression
-   * @param expression the expression with which the name is associated
-   */
-  NamedExpression({Label name, Expression expression}) : this.full(name, expression);
-
   accept(ASTVisitor visitor) => visitor.visitNamedExpression(this);
 
   Token get beginToken => _name.beginToken;
 
   /**
    * Return the element representing the parameter being named by this expression, or `null`
    * if the AST structure has not been resolved or if there is no parameter with the same name as
    * this expression.
    *
    * @return the element representing the parameter being named by this expression
@@ skipping 57 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(Comment comment, List<Annotation> metadata, this.keyword, StringLiteral libraryUri, List<Combinator> combinators, this.semicolon) : super(comment, metadata, libraryUri) {
+    this._combinators = new NodeList<Combinator>(this);
+    this._combinators.addAll(combinators);
   }
 
   /**
-   * Initialize a newly created namespace directive.
+   * Return the combinators used to control how names are imported or exported.
    *
-   * @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
+   * @return the combinators used to control how names are imported or exported
    */
-  NamespaceDirective({Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon}) : this.full(comment, metadata, keyword, libraryUri, combinators, semicolon);
+  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;
-  }
-
-  /**
-   * 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);
+  NativeClause(this.keyword, this.name);
 
   accept(ASTVisitor visitor) => visitor.visitNativeClause(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => name.endToken;
 
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(name, visitor);
   }
 }
 
 /**
  * Instances of the class `NativeFunctionBody` represent a function body that consists of a
  * native keyword followed by a string literal.
  *
  * <pre>
  * nativeFunctionBody ::=
  *     'native' [SimpleStringLiteral] ';'
  * </pre>
  *
  * @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(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);
+  NormalFormalParameter(Comment comment, List<Annotation> metadata, SimpleIdentifier identifier) {
+    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
-   */
-  NormalFormalParameter({Comment comment, List<Annotation> metadata, SimpleIdentifier identifier}) : this.full(comment, metadata, identifier);
-
-  /**
    * Return the documentation comment associated with this parameter, or `null` if this
    * parameter does not have a documentation comment associated with it.
    *
    * @return the documentation comment associated with this parameter
    */
   Comment get documentationComment => _comment;
 
   SimpleIdentifier get identifier => _identifier;
 
   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>
  * nullLiteral ::=
  *     'null'
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 class NullLiteral extends Literal {
   /**
    * The token representing the literal.
    */
   Token literal;
 
   /**
    * Initialize a newly created null literal.
    *
    * @param token the token representing the literal
    */
-  NullLiteral.full(Token token) {
+  NullLiteral(Token token) {
     this.literal = token;
   }
 
-  /**
-   * Initialize a newly created null literal.
-   *
-   * @param token the token representing the literal
-   */
-  NullLiteral({Token token}) : this.full(token);
-
   accept(ASTVisitor visitor) => visitor.visitNullLiteral(this);
 
   Token get beginToken => literal;
 
   Token get endToken => literal;
 
   void visitChildren(ASTVisitor visitor) {
   }
 }
 
@@ skipping 23 matching lines @@
    */
   Token _rightParenthesis;
 
   /**
    * Initialize a newly created parenthesized expression.
    *
    * @param leftParenthesis the left parenthesis
    * @param expression the expression within the parentheses
    * @param rightParenthesis the right parenthesis
    */
-  ParenthesizedExpression.full(Token leftParenthesis, Expression expression, Token rightParenthesis) {
+  ParenthesizedExpression(Token leftParenthesis, Expression expression, Token rightParenthesis) {
     this._leftParenthesis = leftParenthesis;
     this._expression = becomeParentOf(expression);
     this._rightParenthesis = rightParenthesis;
   }
 
-  /**
-   * Initialize a newly created parenthesized expression.
-   *
-   * @param leftParenthesis the left parenthesis
-   * @param expression the expression within the parentheses
-   * @param rightParenthesis the right parenthesis
-   */
-  ParenthesizedExpression({Token leftParenthesis, Expression expression, Token rightParenthesis}) : this.full(leftParenthesis, expression, rightParenthesis);
-
   accept(ASTVisitor visitor) => visitor.visitParenthesizedExpression(this);
 
   Token get beginToken => _leftParenthesis;
 
   Token get endToken => _rightParenthesis;
 
   /**
    * Return the expression within the parentheses.
    *
    * @return the expression within the parentheses
@@ skipping 71 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;
-  }
-
-  /**
-   * Initialize a newly created part directive.
-   *
-   * @param comment the documentation comment associated with this directive
-   * @param metadata the annotations associated with the directive
-   * @param partToken the token representing the 'part' token
-   * @param partUri the URI of the part being included
-   * @param semicolon the semicolon terminating the directive
-   */
-  PartDirective({Comment comment, List<Annotation> metadata, Token partToken, StringLiteral partUri, Token semicolon}) : this.full(comment, metadata, partToken, partUri, semicolon);
+  PartDirective(Comment comment, List<Annotation> metadata, this.partToken, StringLiteral partUri, this.semicolon) : super(comment, metadata, partUri);
 
   accept(ASTVisitor visitor) => visitor.visitPartDirective(this);
 
   Token get endToken => semicolon;
 
   Token get keyword => partToken;
 
   CompilationUnitElement get uriElement => element as CompilationUnitElement;
 
   Token get firstTokenAfterCommentAndMetadata => partToken;
@@ skipping 33 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(Comment comment, List<Annotation> metadata, this.partToken, this.ofToken, LibraryIdentifier libraryName, this.semicolon) : super(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
-   * @param semicolon the semicolon terminating the directive
-   */
-  PartOfDirective({Comment comment, List<Annotation> metadata, Token partToken, Token ofToken, LibraryIdentifier libraryName, Token semicolon}) : this.full(comment, metadata, partToken, ofToken, libraryName, semicolon);
-
   accept(ASTVisitor visitor) => visitor.visitPartOfDirective(this);
 
   Token get endToken => semicolon;
 
   Token get keyword => partToken;
 
   /**
    * Return the name of the library that the containing compilation unit is part of.
    *
    * @return the name of the library that the containing compilation unit is part of
@@ skipping 51 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(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);
-
   accept(ASTVisitor visitor) => visitor.visitPostfixExpression(this);
 
   Token get beginToken => _operand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
@@ skipping 148 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(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);
-
   accept(ASTVisitor visitor) => visitor.visitPrefixExpression(this);
 
   Token get beginToken => operator;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
@@ skipping 142 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(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
-   */
-  PrefixedIdentifier({SimpleIdentifier prefix, Token period, SimpleIdentifier identifier}) : this.full(prefix, period, identifier);
-
   accept(ASTVisitor visitor) => visitor.visitPrefixedIdentifier(this);
 
   Token get beginToken => _prefix.beginToken;
 
   Element get bestElement {
     if (_identifier == null) {
       return null;
     }
     return _identifier.bestElement;
   }
@@ skipping 87 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(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
-   */
-  PropertyAccess({Expression target, Token operator, SimpleIdentifier propertyName}) : this.full(target, operator, propertyName);
-
   accept(ASTVisitor visitor) => visitor.visitPropertyAccess(this);
 
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return operator;
   }
 
   Token get endToken => _propertyName.endToken;
@@ skipping 117 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(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
-   * @param constructorName the name of the constructor that is being invoked
-   * @param argumentList the list of arguments to the constructor
-   */
-  RedirectingConstructorInvocation({Token keyword, Token period, SimpleIdentifier constructorName, ArgumentList argumentList}) : this.full(keyword, period, constructorName, argumentList);
-
   accept(ASTVisitor visitor) => visitor.visitRedirectingConstructorInvocation(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
    * @return the list of arguments to the constructor
    */
   ArgumentList get argumentList => _argumentList;
 
   Token get beginToken => keyword;
@@ skipping 46 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;
-  }
-
-  /**
-   * Initialize a newly created rethrow expression.
-   *
-   * @param keyword the token representing the 'rethrow' keyword
-   */
-  RethrowExpression({Token keyword}) : this.full(keyword);
+  RethrowExpression(this.keyword);
 
   accept(ASTVisitor visitor) => visitor.visitRethrowExpression(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => keyword;
 
   int get precedence => 0;
 
   void visitChildren(ASTVisitor visitor) {
@@ skipping 27 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(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);
-
   accept(ASTVisitor visitor) => visitor.visitReturnStatement(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => semicolon;
 
   /**
    * Return the expression computing the value to be returned, or `null` if no explicit value
    * was provided.
    *
@@ skipping 30 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;
-  }
-
-  /**
-   * Initialize a newly created script tag.
-   *
-   * @param scriptTag the token representing this script tag
-   */
-  ScriptTag({Token scriptTag}) : this.full(scriptTag);
+  ScriptTag(this.scriptTag);
 
   accept(ASTVisitor visitor) => visitor.visitScriptTag(this);
 
   Token get beginToken => scriptTag;
 
   Token get endToken => scriptTag;
 
   void visitChildren(ASTVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `ShowCombinator` represent a combinator that restricts the names
  * being imported to those in a given list.
  *
  * <pre>
  * 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);
+  ShowCombinator(Token keyword, List<SimpleIdentifier> shownNames) : super(keyword) {
+    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(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, SimpleIdentifier identifier) : super(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
-   * @param identifier the name of the parameter being declared
-   */
-  SimpleFormalParameter({Comment comment, List<Annotation> metadata, Token keyword, TypeName type, SimpleIdentifier identifier}) : this.full(comment, metadata, keyword, type, identifier);
-
   accept(ASTVisitor visitor) => visitor.visitSimpleFormalParameter(this);
 
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return identifier.beginToken;
   }
@@ skipping 66 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;
-  }
-
-  /**
-   * Initialize a newly created identifier.
-   *
-   * @param token the token representing the identifier
-   */
-  SimpleIdentifier({Token token}) : this.full(token);
+  SimpleIdentifier(this.token);
 
   accept(ASTVisitor visitor) => visitor.visitSimpleIdentifier(this);
 
   Token get beginToken => token;
 
   Element get bestElement {
     if (_propagatedElement == null) {
       return _staticElement;
     }
     return _propagatedElement;
@@ skipping 229 matching lines @@
    */
   Token literal;
 
   /**
    * 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;
-    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);
+  SimpleStringLiteral(this.literal, String value) {
+    this._value = StringUtilities.intern(value);
+  }
 
   accept(ASTVisitor visitor) => visitor.visitSimpleStringLiteral(this);
 
   Token get beginToken => literal;
 
   Token get endToken => literal;
 
   /**
    * Return the value of the literal.
    *
@@ skipping 74 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);
+  StringInterpolation(List<InterpolationElement> 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(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
-   * @param constructorName the name of the constructor that is being invoked
-   * @param argumentList the list of arguments to the constructor
-   */
-  SuperConstructorInvocation({Token keyword, Token period, SimpleIdentifier constructorName, ArgumentList argumentList}) : this.full(keyword, period, constructorName, argumentList);
-
   accept(ASTVisitor visitor) => visitor.visitSuperConstructorInvocation(this);
 
   /**
    * Return the list of arguments to the constructor.
    *
    * @return the list of arguments to the constructor
    */
   ArgumentList get argumentList => _argumentList;
 
   Token get beginToken => keyword;
@@ skipping 46 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;
-  }
-
-  /**
-   * Initialize a newly created super expression.
-   *
-   * @param keyword the token representing the keyword
-   */
-  SuperExpression({Token keyword}) : this.full(keyword);
+  SuperExpression(this.keyword);
 
   accept(ASTVisitor visitor) => visitor.visitSuperExpression(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => keyword;
 
   int get precedence => 16;
 
   void visitChildren(ASTVisitor visitor) {
@@ skipping 18 matching lines @@
 
   /**
    * Initialize a newly created switch case.
    *
    * @param labels the labels associated with the switch member
    * @param keyword the token representing the 'case' or 'default' keyword
    * @param expression the expression controlling whether the statements will be executed
    * @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
    */
-  SwitchCase.full(List<Label> labels, Token keyword, Expression expression, Token colon, List<Statement> statements) : super.full(labels, keyword, colon, statements) {
+  SwitchCase(List<Label> labels, Token keyword, Expression expression, Token colon, List<Statement> statements) : super(labels, keyword, colon, statements) {
     this._expression = becomeParentOf(expression);
   }
 
-  /**
-   * Initialize a newly created switch case.
-   *
-   * @param labels the labels associated with the switch member
-   * @param keyword the token representing the 'case' or 'default' keyword
-   * @param expression the expression controlling whether the statements will be executed
-   * @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
-   */
-  SwitchCase({List<Label> labels, Token keyword, Expression expression, Token colon, List<Statement> statements}) : this.full(labels, keyword, expression, colon, statements);
-
   accept(ASTVisitor visitor) => visitor.visitSwitchCase(this);
 
   /**
    * Return the expression controlling whether the statements will be executed.
    *
    * @return the expression controlling whether the statements will be executed
    */
   Expression get expression => _expression;
 
   /**
@@ skipping 24 matching lines @@
  */
 class SwitchDefault extends SwitchMember {
   /**
    * Initialize a newly created switch default.
    *
    * @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
    */
-  SwitchDefault.full(List<Label> labels, Token keyword, Token colon, List<Statement> statements) : super.full(labels, keyword, colon, statements);
-
-  /**
-   * Initialize a newly created switch default.
-   *
-   * @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
-   */
-  SwitchDefault({List<Label> labels, Token keyword, Token colon, List<Statement> statements}) : this.full(labels, keyword, colon, statements);
+  SwitchDefault(List<Label> labels, Token keyword, Token colon, List<Statement> statements) : super(labels, keyword, colon, statements);
 
   accept(ASTVisitor visitor) => visitor.visitSwitchDefault(this);
 
   void visitChildren(ASTVisitor visitor) {
     labels.accept(visitor);
     statements.accept(visitor);
   }
 }
 
 /**
  * The abstract class `SwitchMember` defines the behavior common to objects representing
  * elements within a switch statement.
  *
  * <pre>
  * switchMember ::=
  *     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(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(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;
-  }
-
-  /**
-   * 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);
+  SymbolLiteral(this.poundSign, this.components);
 
   accept(ASTVisitor visitor) => visitor.visitSymbolLiteral(this);
 
   Token get beginToken => poundSign;
 
   Token get endToken => components[components.length - 1];
 
   void visitChildren(ASTVisitor visitor) {
   }
 }
@@ skipping 12 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;
-  }
-
-  /**
-   * Initialize a newly created this expression.
-   *
-   * @param keyword the token representing the keyword
-   */
-  ThisExpression({Token keyword}) : this.full(keyword);
+  ThisExpression(this.keyword);
 
   accept(ASTVisitor visitor) => visitor.visitThisExpression(this);
 
   Token get beginToken => keyword;
 
   Token get endToken => keyword;
 
   int get precedence => 16;
 
   void visitChildren(ASTVisitor visitor) {
@@ skipping 20 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(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);
-
   accept(ASTVisitor visitor) => visitor.visitThrowExpression(this);
 
   Token get beginToken => keyword;
 
   Token get endToken {
     if (_expression != null) {
       return _expression.endToken;
     }
     return keyword;
   }
@@ skipping 45 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(Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, this.semicolon) : super(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
-   */
-  TopLevelVariableDeclaration({Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, Token semicolon}) : this.full(comment, metadata, variableList, semicolon);
-
   accept(ASTVisitor visitor) => visitor.visitTopLevelVariableDeclaration(this);
 
   Element get element => null;
 
   Token get endToken => semicolon;
 
   /**
    * Return the top-level variables being declared.
    *
    * @return the top-level variables being declared
@@ skipping 37 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(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;
-  }
-
-  /**
-   * 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);
+  TypeAlias(Comment comment, List<Annotation> metadata, this.keyword, this.semicolon) : super(comment, metadata);
 
   Token get endToken => semicolon;
 
   Token get firstTokenAfterCommentAndMetadata => keyword;
 }
 
 /**
  * Instances of the class `TypeArgumentList` represent a list of type arguments.
  *
  * <pre>
  * typeArguments ::=
  *     '<' typeName (',' typeName)* '>'
  * </pre>
  *
  * @coverage dart.engine.ast
  */
 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(this.leftBracket, List<TypeName> arguments, this.rightBracket) {
+    this._arguments = new NodeList<TypeName>(this);
+    this._arguments.addAll(arguments);
   }
 
+  accept(ASTVisitor visitor) => visitor.visitTypeArgumentList(this);
+
   /**
-   * Initialize a newly created list of type arguments.
+   * Return the type arguments associated with the type.
    *
-   * @param leftBracket the left bracket
-   * @param arguments the type arguments associated with the type
-   * @param rightBracket the right bracket
+   * @return the type arguments associated with the type
    */
-  TypeArgumentList({Token leftBracket, List<TypeName> arguments, Token rightBracket}) : this.full(leftBracket, arguments, rightBracket);
-
-  accept(ASTVisitor visitor) => visitor.visitTypeArgumentList(this);
+  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 17 matching lines @@
    */
   Type2 type;
 
   /**
    * Initialize a newly created type name.
    *
    * @param name the name of the type
    * @param typeArguments the type arguments associated with the type, or `null` if there are
    *          no type arguments
    */
-  TypeName.full(Identifier name, TypeArgumentList typeArguments) {
+  TypeName(Identifier name, TypeArgumentList typeArguments) {
     this._name = becomeParentOf(name);
     this._typeArguments = becomeParentOf(typeArguments);
   }
 
-  /**
-   * Initialize a newly created type name.
-   *
-   * @param name the name of the type
-   * @param typeArguments the type arguments associated with the type, or `null` if there are
-   *          no type arguments
-   */
-  TypeName({Identifier name, TypeArgumentList typeArguments}) : this.full(name, typeArguments);
-
   accept(ASTVisitor visitor) => visitor.visitTypeName(this);
 
   Token get beginToken => _name.beginToken;
 
   Token get endToken {
     if (_typeArguments != null) {
       return _typeArguments.endToken;
     }
     return _name.endToken;
   }
@@ skipping 69 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(Comment comment, List<Annotation> metadata, SimpleIdentifier name, this.keyword, TypeName bound) : super(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
-   * @param bound the name of the upper bound for legal arguments
-   */
-  TypeParameter({Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token keyword, TypeName bound}) : this.full(comment, metadata, name, keyword, bound);
-
   accept(ASTVisitor visitor) => visitor.visitTypeParameter(this);
 
   /**
    * Return the name of the upper bound for legal arguments, or `null` if there was no
    * explicit upper bound.
    *
    * @return the name of the upper bound for legal arguments
    */
   TypeName get bound => _bound;
 
@@ skipping 47 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(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(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
-   */
-  TypedLiteral({Token constKeyword, TypeArgumentList typeArguments}) : this.full(constKeyword, typeArguments);
-
   void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(typeArguments, visitor);
   }
 }
 
 /**
  * The abstract class `UriBasedDirective` defines the behavior common to nodes that represent
  * a directive that references a URI.
  *
  * <pre>
@@ skipping 11 matching lines @@
    */
   StringLiteral _uri;
 
   /**
    * Initialize a newly create URI-based directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param uri the URI referenced by this directive
    */
-  UriBasedDirective.full(Comment comment, List<Annotation> metadata, StringLiteral uri) : super.full(comment, metadata) {
+  UriBasedDirective(Comment comment, List<Annotation> metadata, StringLiteral uri) : super(comment, metadata) {
     this._uri = becomeParentOf(uri);
   }
 
   /**
-   * Initialize a newly create URI-based directive.
-   *
-   * @param comment the documentation comment associated with this directive
-   * @param metadata the annotations associated with the directive
-   * @param uri the URI referenced by this directive
-   */
-  UriBasedDirective({Comment comment, List<Annotation> metadata, StringLiteral uri}) : this.full(comment, metadata, uri);
-
-  /**
    * Return the URI referenced by this directive.
    *
    * @return the URI referenced by this directive
    */
   StringLiteral get uri => _uri;
 
   /**
    * Return the element associated with the URI of this directive, or `null` if the AST
    * structure has not been resolved or if this URI could not be resolved. Examples of the latter
    * case include a directive that contains an invalid URL or a URL that does not exist.
@@ skipping 49 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(Comment comment, List<Annotation> metadata, SimpleIdentifier name, this.equals, Expression initializer) : super(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
-   * @param initializer the expression used to compute the initial value for the variable
-   */
-  VariableDeclaration({Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token equals, Expression initializer}) : this.full(comment, metadata, name, equals, initializer);
-
   accept(ASTVisitor visitor) => visitor.visitVariableDeclaration(this);
 
   /**
    * This overridden implementation of getDocumentationComment() looks in the grandparent node for
    * dartdoc comments if no documentation is specifically available on the node.
    */
   Comment get documentationComment {
     Comment comment = super.documentationComment;
     if (comment == null) {
       if (parent != null && parent.parent != null) {
@@ skipping 104 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(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, List<VariableDeclaration> variables) : super(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(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);
-
   accept(ASTVisitor visitor) => visitor.visitVariableDeclarationStatement(this);
 
   Token get beginToken => _variableList.beginToken;
 
   Token get endToken => semicolon;
 
   /**
    * Return the variables being declared.
    *
    * @return the variables being declared
@@ skipping 52 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(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
-   * @param body the body of the loop
-   */
-  WhileStatement({Token keyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Statement body}) : this.full(keyword, leftParenthesis, condition, rightParenthesis, body);
-
   accept(ASTVisitor visitor) => visitor.visitWhileStatement(this);
 
   Token get beginToken => keyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
@@ skipping 39 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);
+  WithClause(Token withKeyword, List<TypeName> 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 1935 matching lines @@
 
   R visitWithClause(WithClause node) => visitNode(node);
 }
 
 /**
  * Instances of the class `ASTCloner` implement an object that will clone any AST structure
  * that it visits. The cloner will only clone the structure, it will not preserve any resolution
  * results or properties associated with the nodes.
  */
 class ASTCloner implements ASTVisitor<ASTNode> {
-  AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings.full(clone3(node.strings));
+  AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings(clone3(node.strings));
 
-  Annotation visitAnnotation(Annotation node) => new Annotation.full(node.atSign, clone2(node.name), node.period, clone2(node.constructorName), clone2(node.arguments));
+  Annotation visitAnnotation(Annotation node) => new Annotation(node.atSign, clone2(node.name), node.period, clone2(node.constructorName), clone2(node.arguments));
 
-  ArgumentDefinitionTest visitArgumentDefinitionTest(ArgumentDefinitionTest node) => new ArgumentDefinitionTest.full(node.question, clone2(node.identifier));
+  ArgumentDefinitionTest visitArgumentDefinitionTest(ArgumentDefinitionTest node) => new ArgumentDefinitionTest(node.question, clone2(node.identifier));
 
-  ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList.full(node.leftParenthesis, clone3(node.arguments), node.rightParenthesis);
+  ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(node.leftParenthesis, clone3(node.arguments), node.rightParenthesis);
 
-  AsExpression visitAsExpression(AsExpression node) => new AsExpression.full(clone2(node.expression), node.asOperator, clone2(node.type));
+  AsExpression visitAsExpression(AsExpression node) => new AsExpression(clone2(node.expression), node.asOperator, clone2(node.type));
 
-  ASTNode visitAssertStatement(AssertStatement node) => new AssertStatement.full(node.keyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, node.semicolon);
+  ASTNode visitAssertStatement(AssertStatement node) => new AssertStatement(node.keyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, node.semicolon);
 
-  AssignmentExpression visitAssignmentExpression(AssignmentExpression node) => new AssignmentExpression.full(clone2(node.leftHandSide), node.operator, clone2(node.rightHandSide));
+  AssignmentExpression visitAssignmentExpression(AssignmentExpression node) => new AssignmentExpression(clone2(node.leftHandSide), node.operator, clone2(node.rightHandSide));
 
-  BinaryExpression visitBinaryExpression(BinaryExpression node) => new BinaryExpression.full(clone2(node.leftOperand), node.operator, clone2(node.rightOperand));
+  BinaryExpression visitBinaryExpression(BinaryExpression node) => new BinaryExpression(clone2(node.leftOperand), node.operator, clone2(node.rightOperand));
 
-  Block visitBlock(Block node) => new Block.full(node.leftBracket, clone3(node.statements), node.rightBracket);
+  Block visitBlock(Block node) => new Block(node.leftBracket, clone3(node.statements), node.rightBracket);
 
-  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody.full(clone2(node.block));
+  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody(clone2(node.block));
 
-  BooleanLiteral visitBooleanLiteral(BooleanLiteral node) => new BooleanLiteral.full(node.literal, node.value);
+  BooleanLiteral visitBooleanLiteral(BooleanLiteral node) => new BooleanLiteral(node.literal, node.value);
 
-  BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement.full(node.keyword, clone2(node.label), node.semicolon);
+  BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement(node.keyword, clone2(node.label), node.semicolon);
 
-  CascadeExpression visitCascadeExpression(CascadeExpression node) => new CascadeExpression.full(clone2(node.target), clone3(node.cascadeSections));
+  CascadeExpression visitCascadeExpression(CascadeExpression node) => new CascadeExpression(clone2(node.target), clone3(node.cascadeSections));
 
-  CatchClause visitCatchClause(CatchClause node) => new CatchClause.full(node.onKeyword, clone2(node.exceptionType), node.catchKeyword, node.leftParenthesis, clone2(node.exceptionParameter), node.comma, clone2(node.stackTraceParameter), node.rightParenthesis, clone2(node.body));
+  CatchClause visitCatchClause(CatchClause node) => new CatchClause(node.onKeyword, clone2(node.exceptionType), node.catchKeyword, node.leftParenthesis, clone2(node.exceptionParameter), node.comma, clone2(node.stackTraceParameter), node.rightParenthesis, clone2(node.body));
 
   ClassDeclaration visitClassDeclaration(ClassDeclaration node) {
-    ClassDeclaration copy = new ClassDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), node.abstractKeyword, node.classKeyword, clone2(node.name), clone2(node.typeParameters), clone2(node.extendsClause), clone2(node.withClause), clone2(node.implementsClause), node.leftBracket, clone3(node.members), node.rightBracket);
+    ClassDeclaration copy = new ClassDeclaration(clone2(node.documentationComment), clone3(node.metadata), node.abstractKeyword, node.classKeyword, clone2(node.name), clone2(node.typeParameters), clone2(node.extendsClause), clone2(node.withClause), clone2(node.implementsClause), node.leftBracket, clone3(node.members), node.rightBracket);
     copy.nativeClause = clone2(node.nativeClause);
     return copy;
   }
 
-  ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => new ClassTypeAlias.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.name), clone2(node.typeParameters), node.equals, node.abstractKeyword, clone2(node.superclass), clone2(node.withClause), clone2(node.implementsClause), node.semicolon);
+  ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => new ClassTypeAlias(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.name), clone2(node.typeParameters), node.equals, node.abstractKeyword, clone2(node.superclass), clone2(node.withClause), clone2(node.implementsClause), node.semicolon);
 
   Comment visitComment(Comment node) {
     if (node.isDocumentation) {
       return Comment.createDocumentationComment2(node.tokens, clone3(node.references));
     } else if (node.isBlock) {
       return Comment.createBlockComment(node.tokens);
     }
     return Comment.createEndOfLineComment(node.tokens);
   }
 
-  CommentReference visitCommentReference(CommentReference node) => new CommentReference.full(node.newKeyword, clone2(node.identifier));
+  CommentReference visitCommentReference(CommentReference node) => new CommentReference(node.newKeyword, clone2(node.identifier));
 
   CompilationUnit visitCompilationUnit(CompilationUnit node) {
-    CompilationUnit clone = new CompilationUnit.full(node.beginToken, clone2(node.scriptTag), clone3(node.directives), clone3(node.declarations), node.endToken);
+    CompilationUnit clone = new CompilationUnit(node.beginToken, clone2(node.scriptTag), clone3(node.directives), clone3(node.declarations), node.endToken);
     clone.lineInfo = node.lineInfo;
     return clone;
   }
 
-  ConditionalExpression visitConditionalExpression(ConditionalExpression node) => new ConditionalExpression.full(clone2(node.condition), node.question, clone2(node.thenExpression), node.colon, clone2(node.elseExpression));
+  ConditionalExpression visitConditionalExpression(ConditionalExpression node) => new ConditionalExpression(clone2(node.condition), node.question, clone2(node.thenExpression), node.colon, clone2(node.elseExpression));
 
-  ConstructorDeclaration visitConstructorDeclaration(ConstructorDeclaration node) => new ConstructorDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), node.externalKeyword, node.constKeyword, node.factoryKeyword, clone2(node.returnType), node.period, clone2(node.name), clone2(node.parameters), node.separator, clone3(node.initializers), clone2(node.redirectedConstructor), clone2(node.body));
+  ConstructorDeclaration visitConstructorDeclaration(ConstructorDeclaration node) => new ConstructorDeclaration(clone2(node.documentationComment), clone3(node.metadata), node.externalKeyword, node.constKeyword, node.factoryKeyword, clone2(node.returnType), node.period, clone2(node.name), clone2(node.parameters), node.separator, clone3(node.initializers), clone2(node.redirectedConstructor), clone2(node.body));
 
-  ConstructorFieldInitializer visitConstructorFieldInitializer(ConstructorFieldInitializer node) => new ConstructorFieldInitializer.full(node.keyword, node.period, clone2(node.fieldName), node.equals, clone2(node.expression));
+  ConstructorFieldInitializer visitConstructorFieldInitializer(ConstructorFieldInitializer node) => new ConstructorFieldInitializer(node.keyword, node.period, clone2(node.fieldName), node.equals, clone2(node.expression));
 
-  ConstructorName visitConstructorName(ConstructorName node) => new ConstructorName.full(clone2(node.type), node.period, clone2(node.name));
+  ConstructorName visitConstructorName(ConstructorName node) => new ConstructorName(clone2(node.type), node.period, clone2(node.name));
 
-  ContinueStatement visitContinueStatement(ContinueStatement node) => new ContinueStatement.full(node.keyword, clone2(node.label), node.semicolon);
+  ContinueStatement visitContinueStatement(ContinueStatement node) => new ContinueStatement(node.keyword, clone2(node.label), node.semicolon);
 
-  DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) => new DeclaredIdentifier.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.type), clone2(node.identifier));
+  DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) => new DeclaredIdentifier(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.type), clone2(node.identifier));
 
-  DefaultFormalParameter visitDefaultFormalParameter(DefaultFormalParameter node) => new DefaultFormalParameter.full(clone2(node.parameter), node.kind, node.separator, clone2(node.defaultValue));
+  DefaultFormalParameter visitDefaultFormalParameter(DefaultFormalParameter node) => new DefaultFormalParameter(clone2(node.parameter), node.kind, node.separator, clone2(node.defaultValue));
 
-  DoStatement visitDoStatement(DoStatement node) => new DoStatement.full(node.doKeyword, clone2(node.body), node.whileKeyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, node.semicolon);
+  DoStatement visitDoStatement(DoStatement node) => new DoStatement(node.doKeyword, clone2(node.body), node.whileKeyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, node.semicolon);
 
-  DoubleLiteral visitDoubleLiteral(DoubleLiteral node) => new DoubleLiteral.full(node.literal, node.value);
+  DoubleLiteral visitDoubleLiteral(DoubleLiteral node) => new DoubleLiteral(node.literal, node.value);
 
-  EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) => new EmptyFunctionBody.full(node.semicolon);
+  EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) => new EmptyFunctionBody(node.semicolon);
 
-  EmptyStatement visitEmptyStatement(EmptyStatement node) => new EmptyStatement.full(node.semicolon);
+  EmptyStatement visitEmptyStatement(EmptyStatement node) => new EmptyStatement(node.semicolon);
 
-  ExportDirective visitExportDirective(ExportDirective node) => new ExportDirective.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.uri), clone3(node.combinators), node.semicolon);
+  ExportDirective visitExportDirective(ExportDirective node) => new ExportDirective(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.uri), clone3(node.combinators), node.semicolon);
 
-  ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody.full(node.functionDefinition, clone2(node.expression), node.semicolon);
+  ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody(node.functionDefinition, clone2(node.expression), node.semicolon);
 
-  ExpressionStatement visitExpressionStatement(ExpressionStatement node) => new ExpressionStatement.full(clone2(node.expression), node.semicolon);
+  ExpressionStatement visitExpressionStatement(ExpressionStatement node) => new ExpressionStatement(clone2(node.expression), node.semicolon);
 
-  ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause.full(node.keyword, clone2(node.superclass));
+  ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause(node.keyword, clone2(node.superclass));
 
-  FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => new FieldDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), node.staticKeyword, clone2(node.fields), node.semicolon);
+  FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => new FieldDeclaration(clone2(node.documentationComment), clone3(node.metadata), node.staticKeyword, clone2(node.fields), node.semicolon);
 
-  FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => new FieldFormalParameter.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.type), node.thisToken, node.period, clone2(node.identifier), clone2(node.parameters));
+  FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => new FieldFormalParameter(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.type), node.thisToken, node.period, clone2(node.identifier), clone2(node.parameters));
 
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
-      return new ForEachStatement.con2_full(node.forKeyword, node.leftParenthesis, clone2(node.identifier), node.inKeyword, clone2(node.iterator), node.rightParenthesis, clone2(node.body));
+      return new ForEachStatement.con2(node.forKeyword, node.leftParenthesis, clone2(node.identifier), node.inKeyword, clone2(node.iterator), node.rightParenthesis, clone2(node.body));
     }
-    return new ForEachStatement.con1_full(node.forKeyword, node.leftParenthesis, clone2(loopVariable), node.inKeyword, clone2(node.iterator), node.rightParenthesis, clone2(node.body));
+    return new ForEachStatement.con1(node.forKeyword, node.leftParenthesis, clone2(loopVariable), node.inKeyword, clone2(node.iterator), node.rightParenthesis, clone2(node.body));
   }
 
-  FormalParameterList visitFormalParameterList(FormalParameterList node) => new FormalParameterList.full(node.leftParenthesis, clone3(node.parameters), node.leftDelimiter, node.rightDelimiter, node.rightParenthesis);
+  FormalParameterList visitFormalParameterList(FormalParameterList node) => new FormalParameterList(node.leftParenthesis, clone3(node.parameters), node.leftDelimiter, node.rightDelimiter, node.rightParenthesis);
 
-  ForStatement visitForStatement(ForStatement node) => new ForStatement.full(node.forKeyword, node.leftParenthesis, clone2(node.variables), clone2(node.initialization), node.leftSeparator, clone2(node.condition), node.rightSeparator, clone3(node.updaters), node.rightParenthesis, clone2(node.body));
+  ForStatement visitForStatement(ForStatement node) => new ForStatement(node.forKeyword, node.leftParenthesis, clone2(node.variables), clone2(node.initialization), node.leftSeparator, clone2(node.condition), node.rightSeparator, clone3(node.updaters), node.rightParenthesis, clone2(node.body));
 
-  FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => new FunctionDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), node.externalKeyword, clone2(node.returnType), node.propertyKeyword, clone2(node.name), clone2(node.functionExpression));
+  FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => new FunctionDeclaration(clone2(node.documentationComment), clone3(node.metadata), node.externalKeyword, clone2(node.returnType), node.propertyKeyword, clone2(node.name), clone2(node.functionExpression));
 
-  FunctionDeclarationStatement visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => new FunctionDeclarationStatement.full(clone2(node.functionDeclaration));
+  FunctionDeclarationStatement visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => new FunctionDeclarationStatement(clone2(node.functionDeclaration));
 
-  FunctionExpression visitFunctionExpression(FunctionExpression node) => new FunctionExpression.full(clone2(node.parameters), clone2(node.body));
+  FunctionExpression visitFunctionExpression(FunctionExpression node) => new FunctionExpression(clone2(node.parameters), clone2(node.body));
 
-  FunctionExpressionInvocation visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => new FunctionExpressionInvocation.full(clone2(node.function), clone2(node.argumentList));
+  FunctionExpressionInvocation visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => new FunctionExpressionInvocation(clone2(node.function), clone2(node.argumentList));
 
-  FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => new FunctionTypeAlias.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.returnType), clone2(node.name), clone2(node.typeParameters), clone2(node.parameters), node.semicolon);
+  FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => new FunctionTypeAlias(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.returnType), clone2(node.name), clone2(node.typeParameters), clone2(node.parameters), node.semicolon);
 
-  FunctionTypedFormalParameter visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter.full(clone2(node.documentationComment), clone3(node.metadata), clone2(node.returnType), clone2(node.identifier), clone2(node.parameters));
+  FunctionTypedFormalParameter visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter(clone2(node.documentationComment), clone3(node.metadata), clone2(node.returnType), clone2(node.identifier), clone2(node.parameters));
 
-  HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator.full(node.keyword, clone3(node.hiddenNames));
+  HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator(node.keyword, clone3(node.hiddenNames));
 
-  IfStatement visitIfStatement(IfStatement node) => new IfStatement.full(node.ifKeyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, clone2(node.thenStatement), node.elseKeyword, clone2(node.elseStatement));
+  IfStatement visitIfStatement(IfStatement node) => new IfStatement(node.ifKeyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, clone2(node.thenStatement), node.elseKeyword, clone2(node.elseStatement));
 
-  ImplementsClause visitImplementsClause(ImplementsClause node) => new ImplementsClause.full(node.keyword, clone3(node.interfaces));
+  ImplementsClause visitImplementsClause(ImplementsClause node) => new ImplementsClause(node.keyword, clone3(node.interfaces));
 
-  ImportDirective visitImportDirective(ImportDirective node) => new ImportDirective.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.uri), node.asToken, clone2(node.prefix), clone3(node.combinators), node.semicolon);
+  ImportDirective visitImportDirective(ImportDirective node) => new ImportDirective(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.uri), node.asToken, clone2(node.prefix), clone3(node.combinators), node.semicolon);
 
   IndexExpression visitIndexExpression(IndexExpression node) {
     Token period = node.period;
     if (period == null) {
-      return new IndexExpression.forTarget_full(clone2(node.target), node.leftBracket, clone2(node.index), node.rightBracket);
+      return new IndexExpression.forTarget(clone2(node.target), node.leftBracket, clone2(node.index), node.rightBracket);
     } else {
-      return new IndexExpression.forCascade_full(period, node.leftBracket, clone2(node.index), node.rightBracket);
+      return new IndexExpression.forCascade(period, node.leftBracket, clone2(node.index), node.rightBracket);
     }
   }
 
-  InstanceCreationExpression visitInstanceCreationExpression(InstanceCreationExpression node) => new InstanceCreationExpression.full(node.keyword, clone2(node.constructorName), clone2(node.argumentList));
+  InstanceCreationExpression visitInstanceCreationExpression(InstanceCreationExpression node) => new InstanceCreationExpression(node.keyword, clone2(node.constructorName), clone2(node.argumentList));
 
-  IntegerLiteral visitIntegerLiteral(IntegerLiteral node) => new IntegerLiteral.full(node.literal, node.value);
+  IntegerLiteral visitIntegerLiteral(IntegerLiteral node) => new IntegerLiteral(node.literal, node.value);
 
-  InterpolationExpression visitInterpolationExpression(InterpolationExpression node) => new InterpolationExpression.full(node.leftBracket, clone2(node.expression), node.rightBracket);
+  InterpolationExpression visitInterpolationExpression(InterpolationExpression node) => new InterpolationExpression(node.leftBracket, clone2(node.expression), node.rightBracket);
 
-  InterpolationString visitInterpolationString(InterpolationString node) => new InterpolationString.full(node.contents, node.value);
+  InterpolationString visitInterpolationString(InterpolationString node) => new InterpolationString(node.contents, node.value);
 
-  IsExpression visitIsExpression(IsExpression node) => new IsExpression.full(clone2(node.expression), node.isOperator, node.notOperator, clone2(node.type));
+  IsExpression visitIsExpression(IsExpression node) => new IsExpression(clone2(node.expression), node.isOperator, node.notOperator, clone2(node.type));
 
-  Label visitLabel(Label node) => new Label.full(clone2(node.label), node.colon);
+  Label visitLabel(Label node) => new Label(clone2(node.label), node.colon);
 
-  LabeledStatement visitLabeledStatement(LabeledStatement node) => new LabeledStatement.full(clone3(node.labels), clone2(node.statement));
+  LabeledStatement visitLabeledStatement(LabeledStatement node) => new LabeledStatement(clone3(node.labels), clone2(node.statement));
 
-  LibraryDirective visitLibraryDirective(LibraryDirective node) => new LibraryDirective.full(clone2(node.documentationComment), clone3(node.metadata), node.libraryToken, clone2(node.name), node.semicolon);
+  LibraryDirective visitLibraryDirective(LibraryDirective node) => new LibraryDirective(clone2(node.documentationComment), clone3(node.metadata), node.libraryToken, clone2(node.name), node.semicolon);
 
-  LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) => new LibraryIdentifier.full(clone3(node.components));
+  LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) => new LibraryIdentifier(clone3(node.components));
 
-  ListLiteral visitListLiteral(ListLiteral node) => new ListLiteral.full(node.constKeyword, clone2(node.typeArguments), node.leftBracket, clone3(node.elements), node.rightBracket);
+  ListLiteral visitListLiteral(ListLiteral node) => new ListLiteral(node.constKeyword, clone2(node.typeArguments), node.leftBracket, clone3(node.elements), node.rightBracket);
 
-  MapLiteral visitMapLiteral(MapLiteral node) => new MapLiteral.full(node.constKeyword, clone2(node.typeArguments), node.leftBracket, clone3(node.entries), node.rightBracket);
+  MapLiteral visitMapLiteral(MapLiteral node) => new MapLiteral(node.constKeyword, clone2(node.typeArguments), node.leftBracket, clone3(node.entries), node.rightBracket);
 
-  MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) => new MapLiteralEntry.full(clone2(node.key), node.separator, clone2(node.value));
+  MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) => new MapLiteralEntry(clone2(node.key), node.separator, clone2(node.value));
 
-  MethodDeclaration visitMethodDeclaration(MethodDeclaration node) => new MethodDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), node.externalKeyword, node.modifierKeyword, clone2(node.returnType), node.propertyKeyword, node.operatorKeyword, clone2(node.name), clone2(node.parameters), clone2(node.body));
+  MethodDeclaration visitMethodDeclaration(MethodDeclaration node) => new MethodDeclaration(clone2(node.documentationComment), clone3(node.metadata), node.externalKeyword, node.modifierKeyword, clone2(node.returnType), node.propertyKeyword, node.operatorKeyword, clone2(node.name), clone2(node.parameters), clone2(node.body));
 
-  MethodInvocation visitMethodInvocation(MethodInvocation node) => new MethodInvocation.full(clone2(node.target), node.period, clone2(node.methodName), clone2(node.argumentList));
+  MethodInvocation visitMethodInvocation(MethodInvocation node) => new MethodInvocation(clone2(node.target), node.period, clone2(node.methodName), clone2(node.argumentList));
 
-  NamedExpression visitNamedExpression(NamedExpression node) => new NamedExpression.full(clone2(node.name), clone2(node.expression));
+  NamedExpression visitNamedExpression(NamedExpression node) => new NamedExpression(clone2(node.name), clone2(node.expression));
 
-  ASTNode visitNativeClause(NativeClause node) => new NativeClause.full(node.keyword, clone2(node.name));
+  ASTNode visitNativeClause(NativeClause node) => new NativeClause(node.keyword, clone2(node.name));
 
-  NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) => new NativeFunctionBody.full(node.nativeToken, clone2(node.stringLiteral), node.semicolon);
+  NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) => new NativeFunctionBody(node.nativeToken, clone2(node.stringLiteral), node.semicolon);
 
-  NullLiteral visitNullLiteral(NullLiteral node) => new NullLiteral.full(node.literal);
+  NullLiteral visitNullLiteral(NullLiteral node) => new NullLiteral(node.literal);
 
-  ParenthesizedExpression visitParenthesizedExpression(ParenthesizedExpression node) => new ParenthesizedExpression.full(node.leftParenthesis, clone2(node.expression), node.rightParenthesis);
+  ParenthesizedExpression visitParenthesizedExpression(ParenthesizedExpression node) => new ParenthesizedExpression(node.leftParenthesis, clone2(node.expression), node.rightParenthesis);
 
-  PartDirective visitPartDirective(PartDirective node) => new PartDirective.full(clone2(node.documentationComment), clone3(node.metadata), node.partToken, clone2(node.uri), node.semicolon);
+  PartDirective visitPartDirective(PartDirective node) => new PartDirective(clone2(node.documentationComment), clone3(node.metadata), node.partToken, clone2(node.uri), node.semicolon);
 
-  PartOfDirective visitPartOfDirective(PartOfDirective node) => new PartOfDirective.full(clone2(node.documentationComment), clone3(node.metadata), node.partToken, node.ofToken, clone2(node.libraryName), node.semicolon);
+  PartOfDirective visitPartOfDirective(PartOfDirective node) => new PartOfDirective(clone2(node.documentationComment), clone3(node.metadata), node.partToken, node.ofToken, clone2(node.libraryName), node.semicolon);
 
-  PostfixExpression visitPostfixExpression(PostfixExpression node) => new PostfixExpression.full(clone2(node.operand), node.operator);
+  PostfixExpression visitPostfixExpression(PostfixExpression node) => new PostfixExpression(clone2(node.operand), node.operator);
 
-  PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) => new PrefixedIdentifier.full(clone2(node.prefix), node.period, clone2(node.identifier));
+  PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) => new PrefixedIdentifier(clone2(node.prefix), node.period, clone2(node.identifier));
 
-  PrefixExpression visitPrefixExpression(PrefixExpression node) => new PrefixExpression.full(node.operator, clone2(node.operand));
+  PrefixExpression visitPrefixExpression(PrefixExpression node) => new PrefixExpression(node.operator, clone2(node.operand));
 
-  PropertyAccess visitPropertyAccess(PropertyAccess node) => new PropertyAccess.full(clone2(node.target), node.operator, clone2(node.propertyName));
+  PropertyAccess visitPropertyAccess(PropertyAccess node) => new PropertyAccess(clone2(node.target), node.operator, clone2(node.propertyName));
 
-  RedirectingConstructorInvocation visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) => new RedirectingConstructorInvocation.full(node.keyword, node.period, clone2(node.constructorName), clone2(node.argumentList));
+  RedirectingConstructorInvocation visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) => new RedirectingConstructorInvocation(node.keyword, node.period, clone2(node.constructorName), clone2(node.argumentList));
 
-  RethrowExpression visitRethrowExpression(RethrowExpression node) => new RethrowExpression.full(node.keyword);
+  RethrowExpression visitRethrowExpression(RethrowExpression node) => new RethrowExpression(node.keyword);
 
-  ReturnStatement visitReturnStatement(ReturnStatement node) => new ReturnStatement.full(node.keyword, clone2(node.expression), node.semicolon);
+  ReturnStatement visitReturnStatement(ReturnStatement node) => new ReturnStatement(node.keyword, clone2(node.expression), node.semicolon);
 
-  ScriptTag visitScriptTag(ScriptTag node) => new ScriptTag.full(node.scriptTag);
+  ScriptTag visitScriptTag(ScriptTag node) => new ScriptTag(node.scriptTag);
 
-  ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator.full(node.keyword, clone3(node.shownNames));
+  ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator(node.keyword, clone3(node.shownNames));
 
-  SimpleFormalParameter visitSimpleFormalParameter(SimpleFormalParameter node) => new SimpleFormalParameter.full(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.type), clone2(node.identifier));
+  SimpleFormalParameter visitSimpleFormalParameter(SimpleFormalParameter node) => new SimpleFormalParameter(clone2(node.documentationComment), clone3(node.metadata), node.keyword, clone2(node.type), clone2(node.identifier));
 
-  SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) => new SimpleIdentifier.full(node.token);
+  SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) => new SimpleIdentifier(node.token);
 
-  SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) => new SimpleStringLiteral.full(node.literal, node.value);
+  SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) => new SimpleStringLiteral(node.literal, node.value);
 
-  StringInterpolation visitStringInterpolation(StringInterpolation node) => new StringInterpolation.full(clone3(node.elements));
+  StringInterpolation visitStringInterpolation(StringInterpolation node) => new StringInterpolation(clone3(node.elements));
 
-  SuperConstructorInvocation visitSuperConstructorInvocation(SuperConstructorInvocation node) => new SuperConstructorInvocation.full(node.keyword, node.period, clone2(node.constructorName), clone2(node.argumentList));
+  SuperConstructorInvocation visitSuperConstructorInvocation(SuperConstructorInvocation node) => new SuperConstructorInvocation(node.keyword, node.period, clone2(node.constructorName), clone2(node.argumentList));
 
-  SuperExpression visitSuperExpression(SuperExpression node) => new SuperExpression.full(node.keyword);
+  SuperExpression visitSuperExpression(SuperExpression node) => new SuperExpression(node.keyword);
 
-  SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase.full(clone3(node.labels), node.keyword, clone2(node.expression), node.colon, clone3(node.statements));
+  SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase(clone3(node.labels), node.keyword, clone2(node.expression), node.colon, clone3(node.statements));
 
-  SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault.full(clone3(node.labels), node.keyword, node.colon, clone3(node.statements));
+  SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault(clone3(node.labels), node.keyword, node.colon, clone3(node.statements));
 
-  SwitchStatement visitSwitchStatement(SwitchStatement node) => new SwitchStatement.full(node.keyword, node.leftParenthesis, clone2(node.expression), node.rightParenthesis, node.leftBracket, clone3(node.members), node.rightBracket);
+  SwitchStatement visitSwitchStatement(SwitchStatement node) => new SwitchStatement(node.keyword, node.leftParenthesis, clone2(node.expression), node.rightParenthesis, node.leftBracket, clone3(node.members), node.rightBracket);
 
-  ASTNode visitSymbolLiteral(SymbolLiteral node) => new SymbolLiteral.full(node.poundSign, node.components);
+  ASTNode visitSymbolLiteral(SymbolLiteral node) => new SymbolLiteral(node.poundSign, node.components);
 
-  ThisExpression visitThisExpression(ThisExpression node) => new ThisExpression.full(node.keyword);
+  ThisExpression visitThisExpression(ThisExpression node) => new ThisExpression(node.keyword);
 
-  ThrowExpression visitThrowExpression(ThrowExpression node) => new ThrowExpression.full(node.keyword, clone2(node.expression));
+  ThrowExpression visitThrowExpression(ThrowExpression node) => new ThrowExpression(node.keyword, clone2(node.expression));
 
-  TopLevelVariableDeclaration visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration.full(clone2(node.documentationComment), clone3(node.metadata), clone2(node.variables), node.semicolon);
+  TopLevelVariableDeclaration visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration(clone2(node.documentationComment), clone3(node.metadata), clone2(node.variables), node.semicolon);
 
-  TryStatement visitTryStatement(TryStatement node) => new TryStatement.full(node.tryKeyword, clone2(node.body), clone3(node.catchClauses), node.finallyKeyword, clone2(node.finallyBlock));
+  TryStatement visitTryStatement(TryStatement node) => new TryStatement(node.tryKeyword, clone2(node.body), clone3(node.catchClauses), node.finallyKeyword, clone2(node.finallyBlock));
 
-  TypeArgumentList visitTypeArgumentList(TypeArgumentList node) => new TypeArgumentList.full(node.leftBracket, clone3(node.arguments), node.rightBracket);
+  TypeArgumentList visitTypeArgumentList(TypeArgumentList node) => new TypeArgumentList(node.leftBracket, clone3(node.arguments), node.rightBracket);
 
-  TypeName visitTypeName(TypeName node) => new TypeName.full(clone2(node.name), clone2(node.typeArguments));
+  TypeName visitTypeName(TypeName node) => new TypeName(clone2(node.name), clone2(node.typeArguments));
 
-  TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter.full(clone2(node.documentationComment), clone3(node.metadata), clone2(node.name), node.keyword, clone2(node.bound));
+  TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter(clone2(node.documentationComment), clone3(node.metadata), clone2(node.name), node.keyword, clone2(node.bound));
 
-  TypeParameterList visitTypeParameterList(TypeParameterList node) => new TypeParameterList.full(node.leftBracket, clone3(node.typeParameters), node.rightBracket);
+  TypeParameterList visitTypeParameterList(TypeParameterList node) => new TypeParameterList(node.leftBracket, clone3(node.typeParameters), node.rightBracket);
 
-  VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => new VariableDeclaration.full(null, clone3(node.metadata), clone2(node.name), node.equals, clone2(node.initializer));
+  VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => new VariableDeclaration(null, clone3(node.metadata), clone2(node.name), node.equals, clone2(node.initializer));
 
-  VariableDeclarationList visitVariableDeclarationList(VariableDeclarationList node) => new VariableDeclarationList.full(null, clone3(node.metadata), node.keyword, clone2(node.type), clone3(node.variables));
+  VariableDeclarationList visitVariableDeclarationList(VariableDeclarationList node) => new VariableDeclarationList(null, clone3(node.metadata), node.keyword, clone2(node.type), clone3(node.variables));
 
-  VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement.full(clone2(node.variables), node.semicolon);
+  VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement(clone2(node.variables), node.semicolon);
 
-  WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement.full(node.keyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, clone2(node.body));
+  WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(node.keyword, node.leftParenthesis, clone2(node.condition), node.rightParenthesis, clone2(node.body));
 
-  WithClause visitWithClause(WithClause node) => new WithClause.full(node.withKeyword, clone3(node.mixinTypes));
+  WithClause visitWithClause(WithClause node) => new WithClause(node.withKeyword, clone3(node.mixinTypes));
 
   ASTNode clone2(ASTNode node) {
     if (node == null) {
       return null;
     }
     return node.accept(this) as ASTNode;
   }
 
   List clone3(NodeList nodes) {
     int count = nodes.length;
@@ skipping 657 matching lines @@
    * @param oldNode the node to be replaced
    * @param newNode the replacement node
    * @param tokenMap a mapping of old tokens to new tokens (not `null`)
    */
   IncrementalASTCloner(ASTNode oldNode, ASTNode newNode, TokenMap tokenMap) {
     this._oldNode = oldNode;
     this._newNode = newNode;
     this._tokenMap = tokenMap;
   }
 
-  AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings.full(clone5(node.strings));
+  AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings(clone5(node.strings));
 
   Annotation visitAnnotation(Annotation node) {
-    Annotation copy = new Annotation.full(map(node.atSign), clone4(node.name), map(node.period), clone4(node.constructorName), clone4(node.arguments));
+    Annotation copy = new Annotation(map(node.atSign), clone4(node.name), map(node.period), clone4(node.constructorName), clone4(node.arguments));
     copy.element = node.element;
     return copy;
   }
 
   ArgumentDefinitionTest visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
-    ArgumentDefinitionTest copy = new ArgumentDefinitionTest.full(map(node.question), clone4(node.identifier));
+    ArgumentDefinitionTest copy = new ArgumentDefinitionTest(map(node.question), clone4(node.identifier));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList.full(map(node.leftParenthesis), clone5(node.arguments), map(node.rightParenthesis));
+  ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(map(node.leftParenthesis), clone5(node.arguments), map(node.rightParenthesis));
 
   AsExpression visitAsExpression(AsExpression node) {
-    AsExpression copy = new AsExpression.full(clone4(node.expression), map(node.asOperator), clone4(node.type));
+    AsExpression copy = new AsExpression(clone4(node.expression), map(node.asOperator), clone4(node.type));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  ASTNode visitAssertStatement(AssertStatement node) => new AssertStatement.full(map(node.keyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), map(node.semicolon));
+  ASTNode visitAssertStatement(AssertStatement node) => new AssertStatement(map(node.keyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), map(node.semicolon));
 
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) {
-    AssignmentExpression copy = new AssignmentExpression.full(clone4(node.leftHandSide), map(node.operator), clone4(node.rightHandSide));
+    AssignmentExpression copy = new AssignmentExpression(clone4(node.leftHandSide), map(node.operator), clone4(node.rightHandSide));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   BinaryExpression visitBinaryExpression(BinaryExpression node) {
-    BinaryExpression copy = new BinaryExpression.full(clone4(node.leftOperand), map(node.operator), clone4(node.rightOperand));
+    BinaryExpression copy = new BinaryExpression(clone4(node.leftOperand), map(node.operator), clone4(node.rightOperand));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  Block visitBlock(Block node) => new Block.full(map(node.leftBracket), clone5(node.statements), map(node.rightBracket));
+  Block visitBlock(Block node) => new Block(map(node.leftBracket), clone5(node.statements), map(node.rightBracket));
 
-  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody.full(clone4(node.block));
+  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody(clone4(node.block));
 
   BooleanLiteral visitBooleanLiteral(BooleanLiteral node) {
-    BooleanLiteral copy = new BooleanLiteral.full(map(node.literal), node.value);
+    BooleanLiteral copy = new BooleanLiteral(map(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement.full(map(node.keyword), clone4(node.label), map(node.semicolon));
+  BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement(map(node.keyword), clone4(node.label), map(node.semicolon));
 
   CascadeExpression visitCascadeExpression(CascadeExpression node) {
-    CascadeExpression copy = new CascadeExpression.full(clone4(node.target), clone5(node.cascadeSections));
+    CascadeExpression copy = new CascadeExpression(clone4(node.target), clone5(node.cascadeSections));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  CatchClause visitCatchClause(CatchClause node) => new CatchClause.full(map(node.onKeyword), clone4(node.exceptionType), map(node.catchKeyword), map(node.leftParenthesis), clone4(node.exceptionParameter), map(node.comma), clone4(node.stackTraceParameter), map(node.rightParenthesis), clone4(node.body));
+  CatchClause visitCatchClause(CatchClause node) => new CatchClause(map(node.onKeyword), clone4(node.exceptionType), map(node.catchKeyword), map(node.leftParenthesis), clone4(node.exceptionParameter), map(node.comma), clone4(node.stackTraceParameter), map(node.rightParenthesis), clone4(node.body));
 
   ClassDeclaration visitClassDeclaration(ClassDeclaration node) {
-    ClassDeclaration copy = new ClassDeclaration.full(clone4(node.documentationComment), clone5(node.metadata), map(node.abstractKeyword), map(node.classKeyword), clone4(node.name), clone4(node.typeParameters), clone4(node.extendsClause), clone4(node.withClause), clone4(node.implementsClause), map(node.leftBracket), clone5(node.members), map(node.rightBracket));
+    ClassDeclaration copy = new ClassDeclaration(clone4(node.documentationComment), clone5(node.metadata), map(node.abstractKeyword), map(node.classKeyword), clone4(node.name), clone4(node.typeParameters), clone4(node.extendsClause), clone4(node.withClause), clone4(node.implementsClause), map(node.leftBracket), clone5(node.members), map(node.rightBracket));
     copy.nativeClause = clone4(node.nativeClause);
     return copy;
   }
 
-  ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => new ClassTypeAlias.full(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.name), clone4(node.typeParameters), map(node.equals), map(node.abstractKeyword), clone4(node.superclass), clone4(node.withClause), clone4(node.implementsClause), map(node.semicolon));
+  ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => new ClassTypeAlias(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.name), clone4(node.typeParameters), map(node.equals), map(node.abstractKeyword), clone4(node.superclass), clone4(node.withClause), clone4(node.implementsClause), map(node.semicolon));
 
   Comment visitComment(Comment node) {
     if (node.isDocumentation) {
       return Comment.createDocumentationComment2(map2(node.tokens), clone5(node.references));
     } else if (node.isBlock) {
       return Comment.createBlockComment(map2(node.tokens));
     }
     return Comment.createEndOfLineComment(map2(node.tokens));
   }
 
-  CommentReference visitCommentReference(CommentReference node) => new CommentReference.full(map(node.newKeyword), clone4(node.identifier));
+  CommentReference visitCommentReference(CommentReference node) => new CommentReference(map(node.newKeyword), clone4(node.identifier));
 
   CompilationUnit visitCompilationUnit(CompilationUnit node) {
-    CompilationUnit copy = new CompilationUnit.full(map(node.beginToken), clone4(node.scriptTag), clone5(node.directives), clone5(node.declarations), map(node.endToken));
+    CompilationUnit copy = new CompilationUnit(map(node.beginToken), clone4(node.scriptTag), clone5(node.directives), clone5(node.declarations), map(node.endToken));
     copy.lineInfo = node.lineInfo;
     copy.element = node.element;
     return copy;
   }
 
   ConditionalExpression visitConditionalExpression(ConditionalExpression node) {
-    ConditionalExpression copy = new ConditionalExpression.full(clone4(node.condition), map(node.question), clone4(node.thenExpression), map(node.colon), clone4(node.elseExpression));
+    ConditionalExpression copy = new ConditionalExpression(clone4(node.condition), map(node.question), clone4(node.thenExpression), map(node.colon), clone4(node.elseExpression));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   ConstructorDeclaration visitConstructorDeclaration(ConstructorDeclaration node) {
-    ConstructorDeclaration copy = new ConstructorDeclaration.full(clone4(node.documentationComment), clone5(node.metadata), map(node.externalKeyword), map(node.constKeyword), map(node.factoryKeyword), clone4(node.returnType), map(node.period), clone4(node.name), clone4(node.parameters), map(node.separator), clone5(node.initializers), clone4(node.redirectedConstructor), clone4(node.body));
+    ConstructorDeclaration copy = new ConstructorDeclaration(clone4(node.documentationComment), clone5(node.metadata), map(node.externalKeyword), map(node.constKeyword), map(node.factoryKeyword), clone4(node.returnType), map(node.period), clone4(node.name), clone4(node.parameters), map(node.separator), clone5(node.initializers), clone4(node.redirectedConstructor), clone4(node.body));
     copy.element = node.element;
     return copy;
   }
 
-  ConstructorFieldInitializer visitConstructorFieldInitializer(ConstructorFieldInitializer node) => new ConstructorFieldInitializer.full(map(node.keyword), map(node.period), clone4(node.fieldName), map(node.equals), clone4(node.expression));
+  ConstructorFieldInitializer visitConstructorFieldInitializer(ConstructorFieldInitializer node) => new ConstructorFieldInitializer(map(node.keyword), map(node.period), clone4(node.fieldName), map(node.equals), clone4(node.expression));
 
   ConstructorName visitConstructorName(ConstructorName node) {
-    ConstructorName copy = new ConstructorName.full(clone4(node.type), map(node.period), clone4(node.name));
+    ConstructorName copy = new ConstructorName(clone4(node.type), map(node.period), clone4(node.name));
     copy.staticElement = node.staticElement;
     return copy;
   }
 
-  ContinueStatement visitContinueStatement(ContinueStatement node) => new ContinueStatement.full(map(node.keyword), clone4(node.label), map(node.semicolon));
+  ContinueStatement visitContinueStatement(ContinueStatement node) => new ContinueStatement(map(node.keyword), clone4(node.label), map(node.semicolon));
 
-  DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) => new DeclaredIdentifier.full(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.type), clone4(node.identifier));
+  DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) => new DeclaredIdentifier(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.type), clone4(node.identifier));
 
-  DefaultFormalParameter visitDefaultFormalParameter(DefaultFormalParameter node) => new DefaultFormalParameter.full(clone4(node.parameter), node.kind, map(node.separator), clone4(node.defaultValue));
+  DefaultFormalParameter visitDefaultFormalParameter(DefaultFormalParameter node) => new DefaultFormalParameter(clone4(node.parameter), node.kind, map(node.separator), clone4(node.defaultValue));
 
-  DoStatement visitDoStatement(DoStatement node) => new DoStatement.full(map(node.doKeyword), clone4(node.body), map(node.whileKeyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), map(node.semicolon));
+  DoStatement visitDoStatement(DoStatement node) => new DoStatement(map(node.doKeyword), clone4(node.body), map(node.whileKeyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), map(node.semicolon));
 
   DoubleLiteral visitDoubleLiteral(DoubleLiteral node) {
-    DoubleLiteral copy = new DoubleLiteral.full(map(node.literal), node.value);
+    DoubleLiteral copy = new DoubleLiteral(map(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) => new EmptyFunctionBody.full(map(node.semicolon));
+  EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) => new EmptyFunctionBody(map(node.semicolon));
 
-  EmptyStatement visitEmptyStatement(EmptyStatement node) => new EmptyStatement.full(map(node.semicolon));
+  EmptyStatement visitEmptyStatement(EmptyStatement node) => new EmptyStatement(map(node.semicolon));
 
   ExportDirective visitExportDirective(ExportDirective node) {
-    ExportDirective copy = new ExportDirective.full(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.uri), clone5(node.combinators), map(node.semicolon));
+    ExportDirective copy = new ExportDirective(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.uri), clone5(node.combinators), map(node.semicolon));
     copy.element = node.element;
     return copy;
   }
 
-  ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody.full(map(node.functionDefinition), clone4(node.expression), map(node.semicolon));
+  ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody(map(node.functionDefinition), clone4(node.expression), map(node.semicolon));
 
-  ExpressionStatement visitExpressionStatement(ExpressionStatement node) => new ExpressionStatement.full(clone4(node.expression), map(node.semicolon));
+  ExpressionStatement visitExpressionStatement(ExpressionStatement node) => new ExpressionStatement(clone4(node.expression), map(node.semicolon));
 
-  ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause.full(map(node.keyword), clone4(node.superclass));
+  ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause(map(node.keyword), clone4(node.superclass));
 
-  FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => new FieldDeclaration.full(clone4(node.documentationComment), clone5(node.metadata), map(node.staticKeyword), clone4(node.fields), map(node.semicolon));
+  FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => new FieldDeclaration(clone4(node.documentationComment), clone5(node.metadata), map(node.staticKeyword), clone4(node.fields), map(node.semicolon));
 
-  FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => new FieldFormalParameter.full(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.type), map(node.thisToken), map(node.period), clone4(node.identifier), clone4(node.parameters));
+  FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => new FieldFormalParameter(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.type), map(node.thisToken), map(node.period), clone4(node.identifier), clone4(node.parameters));
 
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
-      return new ForEachStatement.con2_full(map(node.forKeyword), map(node.leftParenthesis), clone4(node.identifier), map(node.inKeyword), clone4(node.iterator), map(node.rightParenthesis), clone4(node.body));
+      return new ForEachStatement.con2(map(node.forKeyword), map(node.leftParenthesis), clone4(node.identifier), map(node.inKeyword), clone4(node.iterator), map(node.rightParenthesis), clone4(node.body));
     }
-    return new ForEachStatement.con1_full(map(node.forKeyword), map(node.leftParenthesis), clone4(loopVariable), map(node.inKeyword), clone4(node.iterator), map(node.rightParenthesis), clone4(node.body));
+    return new ForEachStatement.con1(map(node.forKeyword), map(node.leftParenthesis), clone4(loopVariable), map(node.inKeyword), clone4(node.iterator), map(node.rightParenthesis), clone4(node.body));
   }
 
-  FormalParameterList visitFormalParameterList(FormalParameterList node) => new FormalParameterList.full(map(node.leftParenthesis), clone5(node.parameters), map(node.leftDelimiter), map(node.rightDelimiter), map(node.rightParenthesis));
+  FormalParameterList visitFormalParameterList(FormalParameterList node) => new FormalParameterList(map(node.leftParenthesis), clone5(node.parameters), map(node.leftDelimiter), map(node.rightDelimiter), map(node.rightParenthesis));
 
-  ForStatement visitForStatement(ForStatement node) => new ForStatement.full(map(node.forKeyword), map(node.leftParenthesis), clone4(node.variables), clone4(node.initialization), map(node.leftSeparator), clone4(node.condition), map(node.rightSeparator), clone5(node.updaters), map(node.rightParenthesis), clone4(node.body));
+  ForStatement visitForStatement(ForStatement node) => new ForStatement(map(node.forKeyword), map(node.leftParenthesis), clone4(node.variables), clone4(node.initialization), map(node.leftSeparator), clone4(node.condition), map(node.rightSeparator), clone5(node.updaters), map(node.rightParenthesis), clone4(node.body));
 
-  FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => new FunctionDeclaration.full(clone4(node.documentationComment), clone5(node.metadata), map(node.externalKeyword), clone4(node.returnType), map(node.propertyKeyword), clone4(node.name), clone4(node.functionExpression));
+  FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => new FunctionDeclaration(clone4(node.documentationComment), clone5(node.metadata), map(node.externalKeyword), clone4(node.returnType), map(node.propertyKeyword), clone4(node.name), clone4(node.functionExpression));
 
-  FunctionDeclarationStatement visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => new FunctionDeclarationStatement.full(clone4(node.functionDeclaration));
+  FunctionDeclarationStatement visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => new FunctionDeclarationStatement(clone4(node.functionDeclaration));
 
   FunctionExpression visitFunctionExpression(FunctionExpression node) {
-    FunctionExpression copy = new FunctionExpression.full(clone4(node.parameters), clone4(node.body));
+    FunctionExpression copy = new FunctionExpression(clone4(node.parameters), clone4(node.body));
     copy.element = node.element;
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   FunctionExpressionInvocation visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
-    FunctionExpressionInvocation copy = new FunctionExpressionInvocation.full(clone4(node.function), clone4(node.argumentList));
+    FunctionExpressionInvocation copy = new FunctionExpressionInvocation(clone4(node.function), clone4(node.argumentList));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => new FunctionTypeAlias.full(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.returnType), clone4(node.name), clone4(node.typeParameters), clone4(node.parameters), map(node.semicolon));
+  FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => new FunctionTypeAlias(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.returnType), clone4(node.name), clone4(node.typeParameters), clone4(node.parameters), map(node.semicolon));
 
-  FunctionTypedFormalParameter visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter.full(clone4(node.documentationComment), clone5(node.metadata), clone4(node.returnType), clone4(node.identifier), clone4(node.parameters));
+  FunctionTypedFormalParameter visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter(clone4(node.documentationComment), clone5(node.metadata), clone4(node.returnType), clone4(node.identifier), clone4(node.parameters));
 
-  HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator.full(map(node.keyword), clone5(node.hiddenNames));
+  HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator(map(node.keyword), clone5(node.hiddenNames));
 
-  IfStatement visitIfStatement(IfStatement node) => new IfStatement.full(map(node.ifKeyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), clone4(node.thenStatement), map(node.elseKeyword), clone4(node.elseStatement));
+  IfStatement visitIfStatement(IfStatement node) => new IfStatement(map(node.ifKeyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), clone4(node.thenStatement), map(node.elseKeyword), clone4(node.elseStatement));
 
-  ImplementsClause visitImplementsClause(ImplementsClause node) => new ImplementsClause.full(map(node.keyword), clone5(node.interfaces));
+  ImplementsClause visitImplementsClause(ImplementsClause node) => new ImplementsClause(map(node.keyword), clone5(node.interfaces));
 
-  ImportDirective visitImportDirective(ImportDirective node) => new ImportDirective.full(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.uri), map(node.asToken), clone4(node.prefix), clone5(node.combinators), map(node.semicolon));
+  ImportDirective visitImportDirective(ImportDirective node) => new ImportDirective(clone4(node.documentationComment), clone5(node.metadata), map(node.keyword), clone4(node.uri), map(node.asToken), clone4(node.prefix), clone5(node.combinators), map(node.semicolon));
 
   IndexExpression visitIndexExpression(IndexExpression node) {
     Token period = map(node.period);
     IndexExpression copy;
     if (period == null) {
-      copy = new IndexExpression.forTarget_full(clone4(node.target), map(node.leftBracket), clone4(node.index), map(node.rightBracket));
+      copy = new IndexExpression.forTarget(clone4(node.target), map(node.leftBracket), clone4(node.index), map(node.rightBracket));
     } else {
-      copy = new IndexExpression.forCascade_full(period, map(node.leftBracket), clone4(node.index), map(node.rightBracket));
+      copy = new IndexExpression.forCascade(period, map(node.leftBracket), clone4(node.index), map(node.rightBracket));
     }
     copy.auxiliaryElements = node.auxiliaryElements;
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   InstanceCreationExpression visitInstanceCreationExpression(InstanceCreationExpression node) {
-    InstanceCreationExpression copy = new InstanceCreationExpression.full(map(node.keyword), clone4(node.constructorName), clone4(node.argumentList));
+    InstanceCreationExpression copy = new InstanceCreationExpression(map(node.keyword), clone4(node.constructorName), clone4(node.argumentList));
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   IntegerLiteral visitIntegerLiteral(IntegerLiteral node) {
-    IntegerLiteral copy = new IntegerLiteral.full(map(node.literal), node.value);
+    IntegerLiteral copy = new IntegerLiteral(map(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  InterpolationExpression visitInterpolationExpression(InterpolationExpression node) => new InterpolationExpression.full(map(node.leftBracket), clone4(node.expression), map(node.rightBracket));
+  InterpolationExpression visitInterpolationExpression(InterpolationExpression node) => new InterpolationExpression(map(node.leftBracket), clone4(node.expression), map(node.rightBracket));
 
-  InterpolationString visitInterpolationString(InterpolationString node) => new InterpolationString.full(map(node.contents), node.value);
+  InterpolationString visitInterpolationString(InterpolationString node) => new InterpolationString(map(node.contents), node.value);
 
   IsExpression visitIsExpression(IsExpression node) {
-    IsExpression copy = new IsExpression.full(clone4(node.expression), map(node.isOperator), map(node.notOperator), clone4(node.type));
+    IsExpression copy = new IsExpression(clone4(node.expression), map(node.isOperator), map(node.notOperator), clone4(node.type));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  Label visitLabel(Label node) => new Label.full(clone4(node.label), map(node.colon));
+  Label visitLabel(Label node) => new Label(clone4(node.label), map(node.colon));
 
-  LabeledStatement visitLabeledStatement(LabeledStatement node) => new LabeledStatement.full(clone5(node.labels), clone4(node.statement));
+  LabeledStatement visitLabeledStatement(LabeledStatement node) => new LabeledStatement(clone5(node.labels), clone4(node.statement));
 
-  LibraryDirective visitLibraryDirective(LibraryDirective node) => new LibraryDirective.full(clone4(node.documentationComment), clone5(node.metadata), map(node.libraryToken), clone4(node.name), map(node.semicolon));
+  LibraryDirective visitLibraryDirective(LibraryDirective node) => new LibraryDirective(clone4(node.documentationComment), clone5(node.metadata), map(node.libraryToken), clone4(node.name), map(node.semicolon));
 
   LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) {
-    LibraryIdentifier copy = new LibraryIdentifier.full(clone5(node.components));
+    LibraryIdentifier copy = new LibraryIdentifier(clone5(node.components));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   ListLiteral visitListLiteral(ListLiteral node) {
-    ListLiteral copy = new ListLiteral.full(map(node.constKeyword), clone4(node.typeArguments), map(node.leftBracket), clone5(node.elements), map(node.rightBracket));
+    ListLiteral copy = new ListLiteral(map(node.constKeyword), clone4(node.typeArguments), map(node.leftBracket), clone5(node.elements), map(node.rightBracket));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   MapLiteral visitMapLiteral(MapLiteral node) {
-    MapLiteral copy = new MapLiteral.full(map(node.constKeyword), clone4(node.typeArguments), map(node.leftBracket), clone5(node.entries), map(node.rightBracket));
+    MapLiteral copy = new MapLiteral(map(node.constKeyword), clone4(node.typeArguments), map(node.leftBracket), clone5(node.entries), map(node.rightBracket));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) => new MapLiteralEntry.full(clone4(node.key), map(node.separator), clone4(node.value));
+  MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) => new MapLiteralEntry(clone4(node.key), map(node.separator), clone4(node.value));
 
-  MethodDeclaration visitMethodDeclaration(MethodDeclaration node) => new MethodDeclaration.full(clone4(node.documentationComment), clone5(node.metadata), map(node.externalKeyword), map(node.modifierKeyword), clone4(node.returnType), map(node.propertyKeyword), map(node.operatorKeyword), clone4(node.name), clone4(node.parameters), clone4(node.body));
+  MethodDeclaration visitMethodDeclaration(MethodDeclaration node) => new MethodDeclaration(clone4(node.documentationComment), clone5(node.metadata), map(node.externalKeyword), map(node.modifierKeyword), clone4(node.returnType), map(node.propertyKeyword), map(node.operatorKeyword), clone4(node.name), clone4(node.parameters), clone4(node.body));
 
   MethodInvocation visitMethodInvocation(MethodInvocation node) {
-    MethodInvocation copy = new MethodInvocation.full(clone4(node.target), map(node.period), clone4(node.methodName), clone4(node.argumentList));
+    MethodInvocation copy = new MethodInvocation(clone4(node.target), map(node.period), clone4(node.methodName), clone4(node.argumentList));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   NamedExpression visitNamedExpression(NamedExpression node) {
-    NamedExpression copy = new NamedExpression.full(clone4(node.name), clone4(node.expression));
+    NamedExpression copy = new NamedExpression(clone4(node.name), clone4(node.expression));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  ASTNode visitNativeClause(NativeClause node) => new NativeClause.full(map(node.keyword), clone4(node.name));
+  ASTNode visitNativeClause(NativeClause node) => new NativeClause(map(node.keyword), clone4(node.name));
 
-  NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) => new NativeFunctionBody.full(map(node.nativeToken), clone4(node.stringLiteral), map(node.semicolon));
+  NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) => new NativeFunctionBody(map(node.nativeToken), clone4(node.stringLiteral), map(node.semicolon));
 
   NullLiteral visitNullLiteral(NullLiteral node) {
-    NullLiteral copy = new NullLiteral.full(map(node.literal));
+    NullLiteral copy = new NullLiteral(map(node.literal));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   ParenthesizedExpression visitParenthesizedExpression(ParenthesizedExpression node) {
-    ParenthesizedExpression copy = new ParenthesizedExpression.full(map(node.leftParenthesis), clone4(node.expression), map(node.rightParenthesis));
+    ParenthesizedExpression copy = new ParenthesizedExpression(map(node.leftParenthesis), clone4(node.expression), map(node.rightParenthesis));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   PartDirective visitPartDirective(PartDirective node) {
-    PartDirective copy = new PartDirective.full(clone4(node.documentationComment), clone5(node.metadata), map(node.partToken), clone4(node.uri), map(node.semicolon));
+    PartDirective copy = new PartDirective(clone4(node.documentationComment), clone5(node.metadata), map(node.partToken), clone4(node.uri), map(node.semicolon));
     copy.element = node.element;
     return copy;
   }
 
   PartOfDirective visitPartOfDirective(PartOfDirective node) {
-    PartOfDirective copy = new PartOfDirective.full(clone4(node.documentationComment), clone5(node.metadata), map(node.partToken), map(node.ofToken), clone4(node.libraryName), map(node.semicolon));
+    PartOfDirective copy = new PartOfDirective(clone4(node.documentationComment), clone5(node.metadata), map(node.partToken), map(node.ofToken), clone4(node.libraryName), map(node.semicolon));
     copy.element = node.element;
     return copy;
   }
 
   PostfixExpression visitPostfixExpression(PostfixExpression node) {
-    PostfixExpression copy = new PostfixExpression.full(clone4(node.operand), map(node.operator));
+    PostfixExpression copy = new PostfixExpression(clone4(node.operand), map(node.operator));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) {
-    PrefixedIdentifier copy = new PrefixedIdentifier.full(clone4(node.prefix), map(node.period), clone4(node.identifier));
+    PrefixedIdentifier copy = new PrefixedIdentifier(clone4(node.prefix), map(node.period), clone4(node.identifier));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   PrefixExpression visitPrefixExpression(PrefixExpression node) {
-    PrefixExpression copy = new PrefixExpression.full(map(node.operator), clone4(node.operand));
+    PrefixExpression copy = new PrefixExpression(map(node.operator), clone4(node.operand));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
   PropertyAccess visitPropertyAccess(PropertyAccess node) {
-    PropertyAccess copy = new PropertyAccess.full(clone4(node.target), map(node.operator), clone4(node.propertyName));
+    PropertyAccess copy = new PropertyAccess(clone4(node.target), map(node.operator), clone4(node.propertyName));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   RedirectingConstructorInvocation visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
-    RedirectingConstructorInvocation copy = new RedirectingConstructorInvocation.full(map(node.keyword), map(node.period), clone4(node.constructorName), clone4(node.argumentList));
+    RedirectingConstructorInvocation copy = new RedirectingConstructorInvocation(map(node.keyword), map(node.period), clone4(node.constructorName), clone4(node.argumentList));
     copy.staticElement = node.staticElement;
     return copy;
   }
 
   RethrowExpression visitRethrowExpression(RethrowExpression node) {
-    RethrowExpression copy = new RethrowExpression.full(map(node.keyword));
+    RethrowExpression copy = new RethrowExpression(map(node.keyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  ReturnStatement visitReturnStatement(ReturnStatement node) => new ReturnStatement.full(map(node.keyword), clone4(node.expression), map(node.semicolon));
+  ReturnStatement visitReturnStatement(ReturnStatement node) => new ReturnStatement(map(node.keyword), clone4(node.expression), map(node.semicolon));
 
-  ScriptTag visitScriptTag(ScriptTag node) => new ScriptTag.full(map(node.scriptTag));
+  ScriptTag visitScriptTag(ScriptTag node) => new ScriptTag(map(node.scriptTag));
 
-  ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator.full(map(node.keyword), clone5(node.shownNames));
+  ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator(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));
+  SimpleFormalParameter visitSimpleFormalParameter(SimpleFormalParameter node) => new SimpleFormalParameter(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(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);
+    SimpleStringLiteral copy = new SimpleStringLiteral(map(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   StringInterpolation visitStringInterpolation(StringInterpolation node) {
-    StringInterpolation copy = new StringInterpolation.full(clone5(node.elements));
+    StringInterpolation copy = new StringInterpolation(clone5(node.elements));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   SuperConstructorInvocation visitSuperConstructorInvocation(SuperConstructorInvocation node) {
-    SuperConstructorInvocation copy = new SuperConstructorInvocation.full(map(node.keyword), map(node.period), clone4(node.constructorName), clone4(node.argumentList));
+    SuperConstructorInvocation copy = new SuperConstructorInvocation(map(node.keyword), map(node.period), clone4(node.constructorName), clone4(node.argumentList));
     copy.staticElement = node.staticElement;
     return copy;
   }
 
   SuperExpression visitSuperExpression(SuperExpression node) {
-    SuperExpression copy = new SuperExpression.full(map(node.keyword));
+    SuperExpression copy = new SuperExpression(map(node.keyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase.full(clone5(node.labels), map(node.keyword), clone4(node.expression), map(node.colon), clone5(node.statements));
+  SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase(clone5(node.labels), map(node.keyword), clone4(node.expression), map(node.colon), clone5(node.statements));
 
-  SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault.full(clone5(node.labels), map(node.keyword), map(node.colon), clone5(node.statements));
+  SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault(clone5(node.labels), map(node.keyword), map(node.colon), clone5(node.statements));
 
-  SwitchStatement visitSwitchStatement(SwitchStatement node) => new SwitchStatement.full(map(node.keyword), map(node.leftParenthesis), clone4(node.expression), map(node.rightParenthesis), map(node.leftBracket), clone5(node.members), map(node.rightBracket));
+  SwitchStatement visitSwitchStatement(SwitchStatement node) => new SwitchStatement(map(node.keyword), map(node.leftParenthesis), clone4(node.expression), map(node.rightParenthesis), map(node.leftBracket), clone5(node.members), map(node.rightBracket));
 
   ASTNode visitSymbolLiteral(SymbolLiteral node) {
-    SymbolLiteral copy = new SymbolLiteral.full(map(node.poundSign), map2(node.components));
+    SymbolLiteral copy = new SymbolLiteral(map(node.poundSign), map2(node.components));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   ThisExpression visitThisExpression(ThisExpression node) {
-    ThisExpression copy = new ThisExpression.full(map(node.keyword));
+    ThisExpression copy = new ThisExpression(map(node.keyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   ThrowExpression visitThrowExpression(ThrowExpression node) {
-    ThrowExpression copy = new ThrowExpression.full(map(node.keyword), clone4(node.expression));
+    ThrowExpression copy = new ThrowExpression(map(node.keyword), clone4(node.expression));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
-  TopLevelVariableDeclaration visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration.full(clone4(node.documentationComment), clone5(node.metadata), clone4(node.variables), map(node.semicolon));
+  TopLevelVariableDeclaration visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration(clone4(node.documentationComment), clone5(node.metadata), clone4(node.variables), map(node.semicolon));
 
-  TryStatement visitTryStatement(TryStatement node) => new TryStatement.full(map(node.tryKeyword), clone4(node.body), clone5(node.catchClauses), map(node.finallyKeyword), clone4(node.finallyBlock));
+  TryStatement visitTryStatement(TryStatement node) => new TryStatement(map(node.tryKeyword), clone4(node.body), clone5(node.catchClauses), map(node.finallyKeyword), clone4(node.finallyBlock));
 
-  TypeArgumentList visitTypeArgumentList(TypeArgumentList node) => new TypeArgumentList.full(map(node.leftBracket), clone5(node.arguments), map(node.rightBracket));
+  TypeArgumentList visitTypeArgumentList(TypeArgumentList node) => new TypeArgumentList(map(node.leftBracket), clone5(node.arguments), map(node.rightBracket));
 
   TypeName visitTypeName(TypeName node) {
-    TypeName copy = new TypeName.full(clone4(node.name), clone4(node.typeArguments));
+    TypeName copy = new TypeName(clone4(node.name), clone4(node.typeArguments));
     copy.type = node.type;
     return copy;
   }
 
-  TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter.full(clone4(node.documentationComment), clone5(node.metadata), clone4(node.name), map(node.keyword), clone4(node.bound));
+  TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter(clone4(node.documentationComment), clone5(node.metadata), clone4(node.name), map(node.keyword), clone4(node.bound));
 
-  TypeParameterList visitTypeParameterList(TypeParameterList node) => new TypeParameterList.full(map(node.leftBracket), clone5(node.typeParameters), map(node.rightBracket));
+  TypeParameterList visitTypeParameterList(TypeParameterList node) => new TypeParameterList(map(node.leftBracket), clone5(node.typeParameters), map(node.rightBracket));
 
-  VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => new VariableDeclaration.full(null, clone5(node.metadata), clone4(node.name), map(node.equals), clone4(node.initializer));
+  VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => new VariableDeclaration(null, clone5(node.metadata), clone4(node.name), map(node.equals), clone4(node.initializer));
 
-  VariableDeclarationList visitVariableDeclarationList(VariableDeclarationList node) => new VariableDeclarationList.full(null, clone5(node.metadata), map(node.keyword), clone4(node.type), clone5(node.variables));
+  VariableDeclarationList visitVariableDeclarationList(VariableDeclarationList node) => new VariableDeclarationList(null, clone5(node.metadata), map(node.keyword), clone4(node.type), clone5(node.variables));
 
-  VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement.full(clone4(node.variables), map(node.semicolon));
+  VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement(clone4(node.variables), map(node.semicolon));
 
-  WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement.full(map(node.keyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), clone4(node.body));
+  WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(map(node.keyword), map(node.leftParenthesis), clone4(node.condition), map(node.rightParenthesis), clone4(node.body));
 
-  WithClause visitWithClause(WithClause node) => new WithClause.full(map(node.withKeyword), clone5(node.mixinTypes));
+  WithClause visitWithClause(WithClause node) => new WithClause(map(node.withKeyword), clone5(node.mixinTypes));
 
   ASTNode clone4(ASTNode node) {
     if (node == null) {
       return null;
     }
     if (identical(node, _oldNode)) {
       return _newNode as ASTNode;
     }
     return node.accept(this) as ASTNode;
   }
@@ skipping 26 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;
 }