Fresh drop of analyzer-experimental.

pkg/analyzer-experimental/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 'error.dart';
 import 'scanner.dart';
-import 'package:analyzer-experimental/src/generated/utilities_dart.dart';
+import 'engine.dart' show AnalysisEngine;
+import 'utilities_dart.dart';
 import 'element.dart' hide Annotation;
 
 /**
  * The abstract class {@code ASTNode} defines the behavior common to all nodes in the AST structure
  * for a Dart program.
  */
 abstract class ASTNode {
   /**
    * The parent of the node, or {@code null} if the node is the root of an AST structure.
    */
   ASTNode _parent;
   /**
    * A comparator that can be used to sort AST nodes in lexical order. In other words,{@code compare} will return a negative value if the offset of the first node is less than the
    * offset of the second node, zero (0) if the nodes have the same offset, and a positive value if
    * if the offset of the first node is greater than the offset of the second node.
    */
   static Comparator<ASTNode> LEXICAL_ORDER = (ASTNode first, ASTNode second) => second.offset - first.offset;
   /**
    * Use the given visitor to visit this node.
    * @param visitor the visitor that will visit this node
    * @return the value returned by the visitor as a result of visiting this node
    */
   accept(ASTVisitor visitor);
   /**
+   * @return the {@link ASTNode} of given {@link Class} which is {@link ASTNode} itself, or one of
+   * its parents.
+   */
+  ASTNode getAncestor(Type enclosingClass) {
+    ASTNode node = this;
+    while (node != null && !isInstanceOf(node, enclosingClass)) {
+      node = node.parent;
+    }
+    ;

[danrubel, 2013/02/13 20:28:51]

No idea where this extraneous semi-colon came from.

+    return (node as ASTNode);
+  }
+  /**
    * Return the first token included in this node's source range.
    * @return the first token included in this node's source range
    */
   Token get beginToken;
   /**
    * Return the offset of the character immediately following the last character of this node's
    * source range. This is equivalent to {@code node.getOffset() + node.getLength()}. For a
    * compilation unit this will be equal to the length of the unit's source. For synthetic nodes
    * this will be equivalent to the node's offset (because the length is zero (0) by definition).
    * @return the offset of the character just past the node's source range
    */
   int get end => offset + length;
   /**
    * Return the last token included in this node's source range.
    * @return the last token included in this node's source range
    */
   Token get endToken;
   /**
    * Return the number of characters in the node's source range.
    * @return the number of characters in the node's source range
    */
   int get length {
     Token beginToken2 = beginToken;
-    Token endToken3 = endToken;
-    if (beginToken2 == null || endToken3 == null) {
+    Token endToken2 = endToken;
+    if (beginToken2 == null || endToken2 == null) {
       return -1;
     }
-    return endToken3.offset + endToken3.length - beginToken2.offset;
+    return endToken2.offset + endToken2.length - beginToken2.offset;
   }
   /**
    * Return the offset from the beginning of the file to the first character in the node's source
    * range.
    * @return the offset from the beginning of the file to the first character in the node's source
    * range
    */
   int get offset {
     Token beginToken3 = beginToken;
     if (beginToken3 == null) {
       return -1;
     }
     return beginToken.offset;
   }
   /**
    * Return this node's parent node, or {@code null} if this node is the root of an AST structure.
    * <p>
    * Note that the relationship between an AST node and its parent node may change over the lifetime
    * of a node.
    * @return the parent of this node, or {@code null} if none
    */
   ASTNode get parent => _parent;
   /**
    * Return the node at the root of this node's AST structure. Note that this method's performance
    * is linear with respect to the depth of the node in the AST structure (O(depth)).
    * @return the node at the root of this node's AST structure
    */
   ASTNode get root {
     ASTNode root = this;
-    ASTNode parent3 = parent;
-    while (parent3 != null) {
-      root = parent3;
-      parent3 = root.parent;
+    ASTNode parent2 = parent;
+    while (parent2 != null) {
+      root = parent2;
+      parent2 = root.parent;
     }
     return root;
   }
   /**
    * Return {@code true} if this node is a synthetic node. A synthetic node is a node that was
    * introduced by the parser in order to recover from an error in the code. Synthetic nodes always
    * have a length of zero ({@code 0}).
    * @return {@code true} if this node is a synthetic node
    */
   bool isSynthetic() => false;
@@ skipping 15 matching lines @@
    */
   void visitChildren(ASTVisitor<Object> visitor);
   /**
    * Make this node the parent of the given child node.
    * @param child the node that will become a child of this node
    * @return the node that was made a child of this node
    */
   ASTNode becomeParentOf(ASTNode child) {
     if (child != null) {
       ASTNode node = child;
-      node.parent2 = this;
+      node.parent = this;

[Jennifer Messerly, 2013/02/13 21:36:54]

yay!

     }
     return child;
   }
   /**
    * If the given child is not {@code null}, use the given visitor to visit it.
    * @param child the child to be visited
    * @param visitor the visitor that will be used to visit the child
    */
   void safelyVisitChild(ASTNode child, ASTVisitor<Object> visitor) {
     if (child != null) {
       child.accept(visitor);
     }
   }
   /**
    * Set the parent of this node to the given node.
    * @param newParent the node that is to be made the parent of this node
    */
-  void set parent2(ASTNode newParent) {
+  void set parent(ASTNode newParent) {
     _parent = newParent;
   }
+  static int _hashCodeGenerator = 0;
+  final int hashCode = ++_hashCodeGenerator;
 }
 /**
  * The interface {@code ASTVisitor} defines the behavior of objects that can be used to visit an AST
  * structure.
  */
 abstract class ASTVisitor<R> {
   R visitAdjacentStrings(AdjacentStrings node);
   R visitAnnotation(Annotation node);
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node);
   R visitArgumentList(ArgumentList node);
@@ skipping 104 matching lines @@
  */
 class AdjacentStrings extends StringLiteral {
   /**
    * The strings that are implicitly concatenated.
    */
   NodeList<StringLiteral> _strings;
   /**
    * Initialize a newly created list of adjacent strings.
    * @param strings the strings that are implicitly concatenated
    */
-  AdjacentStrings(List<StringLiteral> strings) {
+  AdjacentStrings.full(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 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<Object> visitor) {
     _strings.accept(visitor);
@@ skipping 11 matching lines @@
   Comment _comment;
   /**
    * 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(Comment comment, List<Annotation> metadata) {
+  AnnotatedNode.full(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 12 matching lines @@
   Comment get documentationComment => _comment;
   /**
    * Return the annotations associated with this node.
    * @return the annotations associated with this node
    */
   NodeList<Annotation> get metadata => _metadata;
   /**
    * Set the documentation comment associated with this node to the given comment
    * @param comment the documentation comment to be associated with this node
    */
-  void set documentationComment(Comment comment) {
-    this._comment = becomeParentOf(comment);
+  void set documentationComment(Comment comment2) {
+    this._comment = becomeParentOf(comment2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
@@ skipping 69 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 {@code null} if this annotation is not
    * the invocation of a named constructor
    * @param constructorName the name of the constructor being invoked, or {@code null} if this
    * annotation is not the invocation of a named constructor
    * @param arguments the arguments to the constructor being invoked, or {@code null} if this
    * annotation is not the invocation of a constructor
    */
-  Annotation(Token atSign, Identifier name, Token period, SimpleIdentifier constructorName, ArgumentList arguments) {
+  Annotation.full(Token atSign, Identifier name, Token period, SimpleIdentifier constructorName, ArgumentList arguments) {
     this._atSign = atSign;
     this._name = becomeParentOf(name);
     this._period = period;
     this._constructorName = becomeParentOf(constructorName);
     this._arguments = becomeParentOf(arguments);
   }
+  /**
+   * 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 {@code null} if this annotation is not
+   * the invocation of a named constructor
+   * @param constructorName the name of the constructor being invoked, or {@code null} if this
+   * annotation is not the invocation of a named constructor
+   * @param arguments the arguments to the constructor being invoked, or {@code 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 {@code null} if this annotation is
    * not the invocation of a constructor.
    * @return the arguments to the constructor being invoked
    */
   ArgumentList get arguments => _arguments;
   /**
    * Return the at sign that introduced the annotation.
    * @return the at sign that introduced the annotation
@@ skipping 23 matching lines @@
   /**
    * Return the period before the constructor name, or {@code null} if this annotation is not the
    * invocation of a named constructor.
    * @return the period before the constructor name
    */
   Token get period => _period;
   /**
    * Set the arguments to the constructor being invoked to the given arguments.
    * @param arguments the arguments to the constructor being invoked
    */
-  void set arguments2(ArgumentList arguments) {
-    this._arguments = becomeParentOf(arguments);
+  void set arguments(ArgumentList arguments2) {
+    this._arguments = becomeParentOf(arguments2);
   }
   /**
    * Set the at sign that introduced the annotation to the given token.
    * @param atSign the at sign that introduced the annotation
    */
-  void set atSign2(Token atSign) {
-    this._atSign = atSign;
+  void set atSign(Token atSign2) {
+    this._atSign = atSign2;
   }
   /**
    * Set the name of the constructor being invoked to the given name.
    * @param constructorName the name of the constructor being invoked
    */
-  void set constructorName2(SimpleIdentifier constructorName) {
-    this._constructorName = becomeParentOf(constructorName);
+  void set constructorName(SimpleIdentifier constructorName2) {
+    this._constructorName = becomeParentOf(constructorName2);
   }
   /**
    * Set the name of the class defining the constructor that is being invoked or the name of the
    * field that is being referenced to the given name.
    * @param name the name of the constructor being invoked or the name of the field being referenced
    */
-  void set name2(Identifier name) {
-    this._name = becomeParentOf(name);
+  void set name(Identifier name2) {
+    this._name = becomeParentOf(name2);
   }
   /**
    * Set the period before the constructor name to the given token.
    * @param period the period before the constructor name
    */
-  void set period2(Token period) {
-    this._period = period;
+  void set period(Token period2) {
+    this._period = period2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_arguments, visitor);
   }
 }
 /**
  * Instances of the class {@code ArgumentDefinitionTest} represent an argument definition test.
  * <pre>
  * argumentDefinitionTest ::=
  * '?' {@link SimpleIdentifier identifier}</pre>
  */
 class ArgumentDefinitionTest extends Expression {
   /**
    * The token representing the question mark.
    */
   Token _question;
   /**
    * 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(Token question, SimpleIdentifier identifier) {
+  ArgumentDefinitionTest.full(Token question, SimpleIdentifier identifier) {
     this._question = question;
     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
    */
   SimpleIdentifier get identifier => _identifier;
   /**
    * Return the token representing the question mark.
    * @return the token representing the question mark
    */
   Token get question => _question;
   /**
    * Set the identifier representing the argument being tested to the given identifier.
    * @param identifier the identifier representing the argument being tested
    */
-  void set identifier2(SimpleIdentifier identifier) {
-    this._identifier = becomeParentOf(identifier);
+  void set identifier(SimpleIdentifier identifier5) {
+    this._identifier = becomeParentOf(identifier5);
   }
   /**
    * Set the token representing the question mark to the given token.
    * @param question the token representing the question mark
    */
-  void set question2(Token question) {
-    this._question = question;
+  void set question(Token question2) {
+    this._question = question2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 /**
  * Instances of the class {@code ArgumentList} represent a list of arguments in the invocation of a
  * executable element: a function, method, or constructor.
  * <pre>
  * argumentList ::=
@@ skipping 14 matching lines @@
   /**
    * The right parenthesis.
    */
   Token _rightParenthesis;
   /**
    * Initialize a newly created list of arguments.
    * @param leftParenthesis the left parenthesis
    * @param arguments the expressions producing the values of the arguments
    * @param rightParenthesis the right parenthesis
    */
-  ArgumentList(Token leftParenthesis, List<Expression> arguments, Token rightParenthesis) {
+  ArgumentList.full(Token leftParenthesis, List<Expression> arguments, Token rightParenthesis) {
     this._arguments = new NodeList<Expression>(this);
     this._leftParenthesis = leftParenthesis;
     this._arguments.addAll(arguments);
     this._rightParenthesis = rightParenthesis;
   }
+  /**
+   * Initialize a newly created list of arguments.
+   * @param leftParenthesis the left parenthesis
+   * @param arguments the expressions producing the values of the arguments
+   * @param rightParenthesis the right parenthesis
+   */
+  ArgumentList({Token leftParenthesis, List<Expression> arguments, Token rightParenthesis}) : this.full(leftParenthesis, arguments, rightParenthesis);

[Jennifer Messerly, 2013/02/13 21:36:54]

nice, I liked the named args here!

   accept(ASTVisitor visitor) => visitor.visitArgumentList(this);
   /**
    * Return the expressions producing the values of the arguments. Although the language requires
    * that positional arguments appear before named arguments, this class allows them to be
    * intermixed.
    * @return the expressions producing the values of the arguments
    */
   NodeList<Expression> get arguments => _arguments;
   Token get beginToken => _leftParenthesis;
   Token get endToken => _rightParenthesis;
   /**
    * Return the left parenthesis.
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
   /**
    * Set the left parenthesis to the given token.
    * @param parenthesis the left parenthesis
    */
-  void set leftParenthesis2(Token parenthesis) {
+  void set leftParenthesis(Token parenthesis) {
     _leftParenthesis = parenthesis;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param parenthesis the right parenthesis
    */
-  void set rightParenthesis2(Token parenthesis) {
+  void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _arguments.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code AsExpression} represent an 'as' expression.
  * <pre>
  * asExpression ::={@link Expression expression} 'as' {@link TypeName type}</pre>
@@ skipping 10 matching lines @@
   /**
    * The name of the type being cast to.
    */
   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(Expression expression, Token isOperator, TypeName type) {
+  AsExpression.full(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);
   /**
    * Return the is operator being applied.
    * @return the is operator being applied
    */
   Token get asOperator => _asOperator;
   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
    */
   Expression get expression => _expression;
   /**
    * Return the name of the type being cast to.
    * @return the name of the type being cast to
    */
   TypeName get type => _type;
   /**
    * Set the is operator being applied to the given operator.
    * @param asOperator the is operator being applied
    */
-  void set asOperator2(Token asOperator) {
-    this._asOperator = asOperator;
+  void set asOperator(Token asOperator2) {
+    this._asOperator = asOperator2;
   }
   /**
    * Set the expression used to compute the value being cast to the given expression.
    * @param expression the expression used to compute the value being cast
    */
-  void set expression2(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression2) {
+    this._expression = becomeParentOf(expression2);
   }
   /**
    * Set the name of the type being cast to to the given name.
    * @param name the name of the type being cast to
    */
-  void set type2(TypeName name) {
+  void set type(TypeName name) {
     this._type = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 /**
  * Instances of the class {@code AssertStatement} represent an assert statement.
  * <pre>
@@ skipping 23 matching lines @@
    */
   Token _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 {@code true}
    * @param rightParenthesis the right parenthesis
    * @param semicolon the semicolon terminating the statement
    */
-  AssertStatement(Token keyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon) {
+  AssertStatement.full(Token keyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon) {
     this._keyword = keyword;
     this._leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
     this._rightParenthesis = rightParenthesis;
     this._semicolon = semicolon;
   }
+  /**
+   * 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 {@code 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 {@code true}.
    * @return the condition that is being asserted to be {@code true}
    */
   Expression get condition => _condition;
   Token get endToken => _semicolon;
   /**
    * Return the token representing the 'assert' keyword.
@@ skipping 12 matching lines @@
   Token get rightParenthesis => _rightParenthesis;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * Set the condition that is being asserted to be {@code true} to the given expression.
    * @param the condition that is being asserted to be {@code true}
    */
-  void set condition2(Expression condition) {
-    this._condition = becomeParentOf(condition);
+  void set condition(Expression condition2) {
+    this._condition = becomeParentOf(condition2);
   }
   /**
    * Set the token representing the 'assert' keyword to the given token.
    * @param keyword the token representing the 'assert' keyword
    */
-  void set keyword3(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword3) {
+    this._keyword = keyword3;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param the left parenthesis
    */
-  void set leftParenthesis3(Token leftParenthesis) {
-    this._leftParenthesis = leftParenthesis;
+  void set leftParenthesis(Token leftParenthesis2) {
+    this._leftParenthesis = leftParenthesis2;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
-  void set rightParenthesis3(Token rightParenthesis) {
-    this._rightParenthesis = rightParenthesis;
+  void set rightParenthesis(Token rightParenthesis2) {
+    this._rightParenthesis = rightParenthesis2;
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon2(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon2) {
+    this._semicolon = semicolon2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_condition, visitor);
   }
 }
 /**
  * Instances of the class {@code AssignmentExpression} represent an assignment expression.
  * <pre>
  * assignmentExpression ::={@link Expression leftHandSide} {@link Token operator} {@link Expression rightHandSide}</pre>
  */
@@ skipping 14 matching lines @@
    * The element associated with the operator, or {@code null} if the AST structure has not been
    * resolved, if the operator is not a compound operator, or if the operator could not be resolved.
    */
   MethodElement _element;
   /**
    * 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) {
+  AssignmentExpression.full(Expression leftHandSide, Token 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 element associated with the operator, or {@code null} if the AST structure has not
    * been resolved, if the operator is not a compound operator, or if the operator could not be
    * resolved. One example of the latter case is an operator that is not defined for the type of the
    * left-hand operand.
    * @return the element associated with the operator
    */
   MethodElement get element => _element;
@@ skipping 10 matching lines @@
   Token get operator => _operator;
   /**
    * Return the expression used to compute the right hand side.
    * @return the expression used to compute the right hand side
    */
   Expression get rightHandSide => _rightHandSide;
   /**
    * Set the element associated with the operator to the given element.
    * @param element the element associated with the operator
    */
-  void set element2(MethodElement element) {
-    this._element = element;
+  void set element(MethodElement element3) {
+    this._element = element3;
   }
   /**
    * Return the expression used to compute the left hand side.
    * @param expression the expression used to compute the left hand side
    */
-  void set leftHandSide2(Expression expression) {
+  void set leftHandSide(Expression expression) {
     _leftHandSide = becomeParentOf(expression);
   }
   /**
    * Set the assignment operator being applied to the given operator.
    * @param operator the assignment operator being applied
    */
-  void set operator2(Token operator) {
-    this._operator = operator;
+  void set operator(Token operator2) {
+    this._operator = operator2;
   }
   /**
    * Set the expression used to compute the left hand side to the given expression.
    * @param expression the expression used to compute the left hand side
    */
-  void set rightHandSide2(Expression expression) {
+  void set rightHandSide(Expression expression) {
     _rightHandSide = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_leftHandSide, visitor);
     safelyVisitChild(_rightHandSide, visitor);
   }
 }
 /**
  * Instances of the class {@code BinaryExpression} represent a binary (infix) expression.
  * <pre>
@@ skipping 16 matching lines @@
    * The element associated with the operator, or {@code null} if the AST structure has not been
    * resolved, if the operator is not user definable, or if the operator could not be resolved.
    */
   MethodElement _element;
   /**
    * 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) {
+  BinaryExpression.full(Expression leftOperand, Token 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 element associated with the operator, or {@code null} if the AST structure has not
    * been resolved, if the operator is not user definable, or if the operator could not be resolved.
    * One example of the latter case is an operator that is not defined for the type of the left-hand
    * operand.
    * @return the element associated with the operator
    */
   MethodElement get element => _element;
@@ skipping 10 matching lines @@
   Token get operator => _operator;
   /**
    * Return the expression used to compute the right operand.
    * @return the expression used to compute the right operand
    */
   Expression get rightOperand => _rightOperand;
   /**
    * Set the element associated with the operator to the given element.
    * @param element the element associated with the operator
    */
-  void set element3(MethodElement element) {
-    this._element = element;
+  void set element(MethodElement element4) {
+    this._element = element4;
   }
   /**
    * Set the expression used to compute the left operand to the given expression.
    * @param expression the expression used to compute the left operand
    */
-  void set leftOperand2(Expression expression) {
+  void set leftOperand(Expression expression) {
     _leftOperand = becomeParentOf(expression);
   }
   /**
    * Set the binary operator being applied to the given operator.
    * @return the binary operator being applied
    */
-  void set operator3(Token operator) {
-    this._operator = operator;
+  void set operator(Token operator3) {
+    this._operator = operator3;
   }
   /**
    * Set the expression used to compute the right operand to the given expression.
    * @param expression the expression used to compute the right operand
    */
-  void set rightOperand2(Expression expression) {
+  void set rightOperand(Expression expression) {
     _rightOperand = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_leftOperand, visitor);
     safelyVisitChild(_rightOperand, visitor);
   }
 }
 /**
  * Instances of the class {@code Block} represent a sequence of statements.
  * <pre>
@@ skipping 13 matching lines @@
   /**
    * 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(Token leftBracket, List<Statement> statements, Token rightBracket) {
+  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;
   }
+  /**
+   * 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 left curly bracket.
    * @return the left curly bracket
    */
   Token get leftBracket => _leftBracket;
   /**
    * Return the right curly bracket.
    * @return the right curly bracket
    */
   Token get rightBracket => _rightBracket;
   /**
    * Return the statements contained in the block.
    * @return the statements contained in the block
    */
   NodeList<Statement> get statements => _statements;
   /**
    * Set the left curly bracket to the given token.
    * @param leftBracket the left curly bracket
    */
-  void set leftBracket2(Token leftBracket) {
-    this._leftBracket = leftBracket;
+  void set leftBracket(Token leftBracket2) {
+    this._leftBracket = leftBracket2;
   }
   /**
    * Set the right curly bracket to the given token.
    * @param rightBracket the right curly bracket
    */
-  void set rightBracket2(Token rightBracket) {
-    this._rightBracket = rightBracket;
+  void set rightBracket(Token rightBracket2) {
+    this._rightBracket = rightBracket2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _statements.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code BlockFunctionBody} represent a function body that consists of a
  * block of statements.
  * <pre>
  * blockFunctionBody ::={@link Block block}</pre>
  */
 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(Block block) {
+  BlockFunctionBody.full(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;
   Token get endToken => _block.endToken;
   /**
    * Set the block representing the body of the function to the given block.
    * @param block the block representing the body of the function
    */
-  void set block2(Block block) {
-    this._block = becomeParentOf(block);
+  void set block(Block block2) {
+    this._block = becomeParentOf(block2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_block, visitor);
   }
 }
 /**
  * Instances of the class {@code BooleanLiteral} represent a boolean literal expression.
  * <pre>
  * booleanLiteral ::=
  * 'false' | 'true'
  * </pre>
  */
 class BooleanLiteral extends Literal {
   /**
    * The token representing the literal.
    */
   Token _literal;
   /**
    * 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(Token literal, bool value) {
+  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);
   accept(ASTVisitor visitor) => visitor.visitBooleanLiteral(this);
   Token get beginToken => _literal;
   Token get endToken => _literal;
   /**
    * Return the token representing the literal.
    * @return the token representing the literal
    */
   Token get literal => _literal;
   /**
    * Return the value of the literal.
    * @return the value of the literal
    */
   bool get value => _value;
   bool isSynthetic() => _literal.isSynthetic();
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
-  void set literal2(Token literal) {
-    this._literal = literal;
+  void set literal(Token literal2) {
+    this._literal = literal2;
   }
   /**
    * Set the value of the literal to the given value.
    * @param value the value of the literal
    */
-  void set value4(bool value) {
-    this._value = value;
+  void set value(bool value4) {
+    this._value = value4;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code BreakStatement} represent a break statement.
  * <pre>
  * breakStatement ::=
  * 'break' {@link SimpleIdentifier label}? ';'
  * </pre>
@@ skipping 10 matching lines @@
   /**
    * The semicolon terminating the statement.
    */
   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(Token keyword, SimpleIdentifier label, Token semicolon) {
+  BreakStatement.full(Token keyword, SimpleIdentifier label, Token semicolon) {
     this._keyword = keyword;
     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 token representing the 'break' keyword.
    * @return the token representing the 'break' keyword
    */
   Token get keyword => _keyword;
   /**
    * Return the label associated with the statement, or {@code null} if there is no label.
    * @return the label associated with the statement
    */
   SimpleIdentifier get label => _label;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the 'break' keyword to the given token.
    * @param keyword the token representing the 'break' keyword
    */
-  void set keyword4(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword4) {
+    this._keyword = keyword4;
   }
   /**
    * Set the label associated with the statement to the given identifier.
    * @param identifier the label associated with the statement
    */
-  void set label2(SimpleIdentifier identifier) {
+  void set label(SimpleIdentifier identifier) {
     _label = becomeParentOf(identifier);
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon3(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon3) {
+    this._semicolon = semicolon3;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
  * Instances of the class {@code CascadeExpression} represent a sequence of cascaded expressions:
  * expressions that share a common target. There are three kinds of expressions that can be used in
  * a cascade expression: {@link IndexExpression}, {@link MethodInvocation} and{@link PropertyAccess}.
  * <pre>
@@ skipping 12 matching lines @@
   Expression _target;
   /**
    * The cascade sections sharing the common target.
    */
   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(Expression target, List<Expression> cascadeSections) {
+  CascadeExpression.full(Expression target, List<Expression> cascadeSections) {
     this._cascadeSections = new NodeList<Expression>(this);
     this._target = becomeParentOf(target);
     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;
   /**
    * 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;
   /**
    * 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 target2(Expression target) {
-    this._target = becomeParentOf(target);
+  void set target(Expression target2) {
+    this._target = becomeParentOf(target2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
     _cascadeSections.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code CatchClause} represent a catch clause within a try statement.
  * <pre>
  * onPart ::=
@@ skipping 44 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(Token onKeyword, TypeName exceptionType, Token catchKeyword, Token leftParenthesis, SimpleIdentifier exceptionParameter, Token comma, SimpleIdentifier stackTraceParameter, Token rightParenthesis, Block body) {
+  CatchClause.full(Token onKeyword, TypeName exceptionType, Token catchKeyword, Token leftParenthesis, SimpleIdentifier exceptionParameter, Token comma, SimpleIdentifier stackTraceParameter, Token rightParenthesis, Block body) {
     this._onKeyword = onKeyword;
     this._exceptionType = becomeParentOf(exceptionType);
     this._catchKeyword = catchKeyword;
     this._leftParenthesis = leftParenthesis;
     this._exceptionParameter = becomeParentOf(exceptionParameter);
     this._comma = comma;
     this._stackTraceParameter = becomeParentOf(stackTraceParameter);
     this._rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
+  /**
+   * 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;
   }
   /**
    * Return the body of the catch block.
    * @return the body of the catch block
@@ skipping 39 matching lines @@
   Token get rightParenthesis => _rightParenthesis;
   /**
    * Return the parameter whose value will be the stack trace associated with the exception.
    * @return the parameter whose value will be the stack trace associated with the exception
    */
   SimpleIdentifier get stackTraceParameter => _stackTraceParameter;
   /**
    * Set the body of the catch block to the given block.
    * @param block the body of the catch block
    */
-  void set body2(Block block) {
+  void set body(Block block) {
     _body = becomeParentOf(block);
   }
   /**
    * Set the token representing the 'catch' keyword to the given token.
    * @param catchKeyword the token representing the 'catch' keyword
    */
-  void set catchKeyword2(Token catchKeyword) {
-    this._catchKeyword = catchKeyword;
+  void set catchKeyword(Token catchKeyword2) {
+    this._catchKeyword = catchKeyword2;
   }
   /**
    * Set the comma to the given token.
    * @param comma the comma
    */
-  void set comma2(Token comma) {
-    this._comma = comma;
+  void set comma(Token comma2) {
+    this._comma = comma2;
   }
   /**
    * Set the parameter whose value will be the exception that was thrown to the given parameter.
    * @param parameter the parameter whose value will be the exception that was thrown
    */
-  void set exceptionParameter2(SimpleIdentifier parameter) {
+  void set exceptionParameter(SimpleIdentifier parameter) {
     _exceptionParameter = becomeParentOf(parameter);
   }
   /**
    * Set the type of exceptions caught by this catch clause to the given type.
    * @param exceptionType the type of exceptions caught by this catch clause
    */
-  void set exceptionType2(TypeName exceptionType) {
-    this._exceptionType = exceptionType;
+  void set exceptionType(TypeName exceptionType2) {
+    this._exceptionType = exceptionType2;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param parenthesis the left parenthesis
    */
-  void set leftParenthesis4(Token parenthesis) {
+  void set leftParenthesis(Token parenthesis) {
     _leftParenthesis = parenthesis;
   }
   /**
    * Set the token representing the 'on' keyword to the given keyword.
    * @param onKeyword the token representing the 'on' keyword
    */
-  void set onKeyword2(Token onKeyword) {
-    this._onKeyword = onKeyword;
+  void set onKeyword(Token onKeyword2) {
+    this._onKeyword = onKeyword2;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param parenthesis the right parenthesis
    */
-  void set rightParenthesis4(Token parenthesis) {
+  void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
   /**
    * Set the parameter whose value will be the stack trace associated with the exception to the
    * given parameter.
    * @param parameter the parameter whose value will be the stack trace associated with the
    * exception
    */
-  void set stackTraceParameter2(SimpleIdentifier parameter) {
+  void set stackTraceParameter(SimpleIdentifier parameter) {
     _stackTraceParameter = becomeParentOf(parameter);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_exceptionType, visitor);
     safelyVisitChild(_exceptionParameter, visitor);
     safelyVisitChild(_stackTraceParameter, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
@@ skipping 56 matching lines @@
    * @param classKeyword the token representing the 'class' keyword
    * @param name the name of the class being declared
    * @param typeParameters the type parameters for the class
    * @param extendsClause the extends clause for the class
    * @param withClause the with clause for the class
    * @param implementsClause the implements clause for the class
    * @param leftBracket the left curly bracket
    * @param members the members defined by the class
    * @param rightBracket the right curly bracket
    */
-  ClassDeclaration(Comment comment, List<Annotation> metadata, Token abstractKeyword, Token classKeyword, SimpleIdentifier name, TypeParameterList typeParameters, ExtendsClause extendsClause, WithClause withClause, ImplementsClause implementsClause, Token leftBracket, List<ClassMember> members, Token rightBracket) : super(comment, metadata) {
+  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;
     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;
   }
+  /**
+   * 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 {@code 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);
   /**
    * Return the 'abstract' keyword, or {@code null} if the keyword was absent.
    * @return the 'abstract' keyword
    */
   Token get abstractKeyword => _abstractKeyword;
   /**
    * Return the token representing the 'class' keyword.
    * @return the token representing the 'class' keyword
    */
   Token get classKeyword => _classKeyword;
   /**
    * @return the {@link ClassElement} associated with this identifier, or {@code null} if the AST
    * structure has not been resolved or if this identifier could not be resolved.
    */
-  ClassElement get element => _name != null ? _name.element as ClassElement : null;
+  ClassElement get element => _name != null ? (_name.element as ClassElement) : null;
   Token get endToken => _rightBracket;
   /**
    * Return the extends clause for this class, or {@code null} if the class does not extend any
    * other class.
    * @return the extends clause for this class
    */
   ExtendsClause get extendsClause => _extendsClause;
   /**
    * Return the implements clause for the class, or {@code null} if the class does not implement any
    * interfaces.
@@ skipping 28 matching lines @@
   TypeParameterList get typeParameters => _typeParameters;
   /**
    * Return the with clause for the class, or {@code null} if the class does not have a with clause.
    * @return the with clause for the class
    */
   WithClause get withClause => _withClause;
   /**
    * Set the 'abstract' keyword to the given keyword.
    * @param abstractKeyword the 'abstract' keyword
    */
-  void set abstractKeyword2(Token abstractKeyword) {
-    this._abstractKeyword = abstractKeyword;
+  void set abstractKeyword(Token abstractKeyword2) {
+    this._abstractKeyword = abstractKeyword2;
   }
   /**
    * Set the token representing the 'class' keyword to the given token.
    * @param classKeyword the token representing the 'class' keyword
    */
-  void set classKeyword2(Token classKeyword) {
-    this._classKeyword = classKeyword;
+  void set classKeyword(Token classKeyword2) {
+    this._classKeyword = classKeyword2;
   }
   /**
    * Set the extends clause for this class to the given clause.
    * @param extendsClause the extends clause for this class
    */
-  void set extendsClause2(ExtendsClause extendsClause) {
-    this._extendsClause = becomeParentOf(extendsClause);
+  void set extendsClause(ExtendsClause extendsClause3) {
+    this._extendsClause = becomeParentOf(extendsClause3);
   }
   /**
    * Set the implements clause for the class to the given clause.
    * @param implementsClause the implements clause for the class
    */
-  void set implementsClause2(ImplementsClause implementsClause) {
-    this._implementsClause = becomeParentOf(implementsClause);
+  void set implementsClause(ImplementsClause implementsClause4) {
+    this._implementsClause = becomeParentOf(implementsClause4);
   }
   /**
    * Set the left curly bracket to the given token.
    * @param leftBracket the left curly bracket
    */
-  void set leftBracket3(Token leftBracket) {
-    this._leftBracket = leftBracket;
+  void set leftBracket(Token leftBracket3) {
+    this._leftBracket = leftBracket3;
   }
   /**
    * Set the name of the class being declared to the given identifier.
    * @param identifier the name of the class being declared
    */
-  void set name3(SimpleIdentifier identifier) {
+  void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
   /**
    * Set the right curly bracket to the given token.
    * @param rightBracket the right curly bracket
    */
-  void set rightBracket3(Token rightBracket) {
-    this._rightBracket = rightBracket;
+  void set rightBracket(Token rightBracket3) {
+    this._rightBracket = rightBracket3;
   }
   /**
    * Set the type parameters for the class to the given list of type parameters.
    * @param typeParameters the type parameters for the class
    */
-  void set typeParameters2(TypeParameterList typeParameters) {
-    this._typeParameters = typeParameters;
+  void set typeParameters(TypeParameterList typeParameters2) {
+    this._typeParameters = typeParameters2;
   }
   /**
    * Set the with clause for the class to the given clause.
    * @param withClause the with clause for the class
    */
-  void set withClause2(WithClause withClause) {
-    this._withClause = becomeParentOf(withClause);
+  void set withClause(WithClause withClause4) {
+    this._withClause = becomeParentOf(withClause4);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(documentationComment, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_extendsClause, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
     members.accept(visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_abstractKeyword != null) {
       return _abstractKeyword;
     }
     return _classKeyword;
   }
 }
 /**
  * The abstract class {@code ClassMember} defines the behavior common to nodes that declare a name
  * within the scope of a class.
  */
 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(Comment comment, List<Annotation> metadata) : super(comment, metadata) {
+  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);
 }
 /**
  * Instances of the class {@code ClassTypeAlias} represent a class type alias.
  * <pre>
  * classTypeAlias ::={@link SimpleIdentifier identifier} {@link TypeParameterList typeParameters}? '=' 'abstract'? mixinApplication
  * mixinApplication ::={@link TypeName superclass} {@link WithClause withClause} {@link ImplementsClause implementsClause}? ';'
  * </pre>
  */
 class ClassTypeAlias extends TypeAlias {
   /**
@@ skipping 33 matching lines @@
    * @param keyword the token representing the 'typedef' keyword
    * @param name the name of the class being declared
    * @param typeParameters the type parameters for the class
    * @param equals the token for the '=' separating the name from the definition
    * @param abstractKeyword the token for the 'abstract' keyword
    * @param superclass the name of the superclass of the class being declared
    * @param withClause the with clause for this class
    * @param implementsClause the implements clause for this class
    * @param semicolon the semicolon terminating the declaration
    */
-  ClassTypeAlias(Comment comment, List<Annotation> metadata, Token keyword, SimpleIdentifier name, TypeParameterList typeParameters, Token equals, Token abstractKeyword, TypeName superclass, WithClause withClause, ImplementsClause implementsClause, Token semicolon) : super(comment, metadata, keyword, semicolon) {
+  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) {
     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);
   /**
    * Return the token for the 'abstract' keyword, or {@code null} if this is not defining an
    * abstract class.
    * @return the token for the 'abstract' keyword
    */
   Token get abstractKeyword => _abstractKeyword;
   /**
    * Return the {@link ClassElement} associated with this type alias, or {@code null} if the AST
    * structure has not been resolved.
    * @return the {@link ClassElement} associated with this type alias
    */
-  ClassElement get element => _name != null ? _name.element as ClassElement : null;
+  ClassElement get element => _name != null ? (_name.element as ClassElement) : null;
   /**
    * Return the token for the '=' separating the name from the definition.
    * @return the token for the '=' separating the name from the definition
    */
   Token get equals => _equals;
   /**
    * Return the implements clause for this class, or {@code null} if there is no implements clause.
    * @return the implements clause for this class
    */
   ImplementsClause get implementsClause => _implementsClause;
@@ skipping 15 matching lines @@
   TypeParameterList get typeParameters => _typeParameters;
   /**
    * Return the with clause for this class.
    * @return the with clause for this class
    */
   WithClause get withClause => _withClause;
   /**
    * Set the token for the 'abstract' keyword to the given token.
    * @param abstractKeyword the token for the 'abstract' keyword
    */
-  void set abstractKeyword3(Token abstractKeyword) {
-    this._abstractKeyword = abstractKeyword;
+  void set abstractKeyword(Token abstractKeyword3) {
+    this._abstractKeyword = abstractKeyword3;
   }
   /**
    * Set the token for the '=' separating the name from the definition to the given token.
    * @param equals the token for the '=' separating the name from the definition
    */
-  void set equals4(Token equals) {
-    this._equals = equals;
+  void set equals(Token equals4) {
+    this._equals = equals4;
   }
   /**
    * Set the implements clause for this class to the given implements clause.
    * @param implementsClause the implements clause for this class
    */
-  void set implementsClause3(ImplementsClause implementsClause) {
-    this._implementsClause = becomeParentOf(implementsClause);
+  void set implementsClause(ImplementsClause implementsClause5) {
+    this._implementsClause = becomeParentOf(implementsClause5);
   }
   /**
    * Set the name of the class being declared to the given identifier.
    * @param name the name of the class being declared
    */
-  void set name4(SimpleIdentifier name) {
-    this._name = becomeParentOf(name);
+  void set name(SimpleIdentifier name3) {
+    this._name = becomeParentOf(name3);
   }
   /**
    * Set the name of the superclass of the class being declared to the given name.
    * @param superclass the name of the superclass of the class being declared
    */
-  void set superclass2(TypeName superclass) {
-    this._superclass = becomeParentOf(superclass);
+  void set superclass(TypeName superclass2) {
+    this._superclass = becomeParentOf(superclass2);
   }
   /**
    * Set the type parameters for the class to the given list of parameters.
    * @param typeParameters the type parameters for the class
    */
-  void set typeParameters3(TypeParameterList typeParameters) {
-    this._typeParameters = becomeParentOf(typeParameters);
+  void set typeParameters(TypeParameterList typeParameters3) {
+    this._typeParameters = becomeParentOf(typeParameters3);
   }
   /**
    * Set the with clause for this class to the given with clause.
    * @param withClause the with clause for this class
    */
-  void set withClause3(WithClause withClause) {
-    this._withClause = becomeParentOf(withClause);
+  void set withClause(WithClause withClause5) {
+    this._withClause = becomeParentOf(withClause5);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_superclass, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
   }
 }
 /**
  * Instances of the class {@code Combinator} represent the combinator associated with an import
  * directive.
  * <pre>
  * combinator ::={@link HideCombinator hideCombinator}| {@link ShowCombinator showCombinator}</pre>
  */
 abstract class Combinator extends ASTNode {
   /**
    * 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(Token keyword) {
+  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);
   Token get beginToken => _keyword;
   /**
    * Return the keyword specifying what kind of processing is to be done on the imported names.
    * @return the keyword specifying what kind of processing is to be done on the imported names
    */
   Token get keyword => _keyword;
   /**
    * Set the keyword specifying what kind of processing is to be done on the imported names to the
    * given token.
    * @param keyword the keyword specifying what kind of processing is to be done on the imported
    * names
    */
-  void set keyword5(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword5) {
+    this._keyword = keyword5;
   }
 }
 /**
  * Instances of the class {@code Comment} represent a comment within the source code.
  * <pre>
  * comment ::=
  * endOfLineComment
  * | blockComment
  * | documentationComment
  * endOfLineComment ::=
  * '//' (CHARACTER - EOL)* EOL
  * blockComment ::=
  * '/ *' CHARACTER* '&#42;/'
  * documentationComment ::=
  * '/ **' (CHARACTER | {@link CommentReference commentReference})* '&#42;/'
  * | ('///' (CHARACTER - EOL)* EOL)+
  * </pre>
  */
 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(tokens, CommentType.BLOCK, null);
+  static Comment createBlockComment(List<Token> tokens) => new Comment.full(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(tokens, CommentType.DOCUMENTATION, new List<CommentReference>());
+  static Comment createDocumentationComment(List<Token> tokens) => new Comment.full(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(tokens, CommentType.DOCUMENTATION, references);
+  static Comment createDocumentationComment2(List<Token> tokens, List<CommentReference> references) => new Comment.full(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(tokens, CommentType.END_OF_LINE, null);
+  static Comment createEndOfLineComment(List<Token> tokens) => new Comment.full(tokens, CommentType.END_OF_LINE, null);
   /**
    * The tokens representing the comment.
    */
   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;
   /**
    * 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) {
+  Comment.full(List<Token> tokens, CommentType type, List<CommentReference> references) {
     this._references = new NodeList<CommentReference>(this);
     this._tokens = tokens;
     this._type = type;
     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 {@code true} if this is a block comment.
    * @return {@code true} if this is a block comment
    */
-  bool isBlock() => _type == CommentType.BLOCK;
+  bool isBlock() => identical(_type, CommentType.BLOCK);
   /**
    * Return {@code true} if this is a documentation comment.
    * @return {@code true} if this is a documentation comment
    */
-  bool isDocumentation() => _type == CommentType.DOCUMENTATION;
+  bool isDocumentation() => identical(_type, CommentType.DOCUMENTATION);
   /**
    * Return {@code true} if this is an end-of-line comment.
    * @return {@code true} if this is an end-of-line comment
    */
-  bool isEndOfLine() => _type == CommentType.END_OF_LINE;
+  bool isEndOfLine() => identical(_type, CommentType.END_OF_LINE);
   void visitChildren(ASTVisitor<Object> visitor) {
     _references.accept(visitor);
   }
 }
 /**
  * The enumeration {@code CommentType} encodes all the different types of comments that are
  * recognized by the parser.
  */
 class CommentType {
   /**
@@ skipping 30 matching lines @@
   Token _newKeyword;
   /**
    * The identifier being referenced.
    */
   Identifier _identifier;
   /**
    * Initialize a newly created reference to a Dart element.
    * @param newKeyword the token representing the 'new' keyword
    * @param identifier the identifier being referenced
    */
-  CommentReference(Token newKeyword, Identifier identifier) {
+  CommentReference.full(Token newKeyword, Identifier identifier) {
     this._newKeyword = newKeyword;
     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
    */
   Identifier get identifier => _identifier;
   /**
    * Return the token representing the 'new' keyword, or {@code null} if there was no 'new' keyword.
    * @return the token representing the 'new' keyword
    */
   Token get newKeyword => _newKeyword;
   /**
    * Set the identifier being referenced to the given identifier.
    * @param identifier the identifier being referenced
    */
-  void set identifier3(Identifier identifier) {
-    identifier = becomeParentOf(identifier);
+  void set identifier(Identifier identifier18) {
+    identifier18 = becomeParentOf(identifier18);
   }
   /**
    * Set the token representing the 'new' keyword to the given token.
    * @param newKeyword the token representing the 'new' keyword
    */
-  void set newKeyword2(Token newKeyword) {
-    this._newKeyword = newKeyword;
+  void set newKeyword(Token newKeyword2) {
+    this._newKeyword = newKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 /**
  * Instances of the class {@code CompilationUnit} represent a compilation unit.
  * <p>
  * While the grammar restricts the order of the directives and declarations within a compilation
  * unit, this class does not enforce those restrictions. In particular, the children of a
@@ skipping 26 matching lines @@
    * The last token in the token stream that was parsed to form this compilation unit. This token
    * should always have a type of {@link TokenType.EOF}.
    */
   Token _endToken;
   /**
    * The element associated with this compilation unit, or {@code null} if the AST structure has not
    * been resolved.
    */
   CompilationUnitElement _element;
   /**
-   * The syntax errors encountered when the receiver was parsed.
+   * The {@link LineInfo} for this {@link CompilationUnit}.
    */
-  List<AnalysisError> _syntacticErrors;
+  LineInfo _lineInfo;
+  /**
+   * The parsing errors encountered when the receiver was parsed.
+   */
+  List<AnalysisError> _parsingErrors = AnalysisError.NO_ERRORS;
+  /**
+   * The resolution errors encountered when the receiver was resolved.
+   */
+  List<AnalysisError> _resolutionErrors = AnalysisError.NO_ERRORS;
   /**
    * 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) {
+  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;
     this._scriptTag = becomeParentOf(scriptTag);
     this._directives.addAll(directives);
     this._declarations.addAll(declarations);
     this._endToken = endToken;
   }
+  /**
+   * 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;
   /**
    * Return the directives contained in this compilation unit.
    * @return the directives contained in this compilation unit
    */
   NodeList<Directive> get directives => _directives;
   /**
    * Return the element associated with this compilation unit, or {@code null} if the AST structure
    * has not been resolved.
    * @return the element associated with this compilation unit
    */
   CompilationUnitElement get element => _element;
   Token get endToken => _endToken;
   /**
    * Return an array containing all of the errors associated with the receiver. If the receiver has
    * not been resolved, then return {@code null}.
    * @return an array of errors (contains no {@code null}s) or {@code null} if the receiver has not
    * been resolved
    */
   List<AnalysisError> get errors {
-    throw new UnsupportedOperationException();
+    List<AnalysisError> parserErrors = parsingErrors;
+    List<AnalysisError> resolverErrors = resolutionErrors;
+    if (resolverErrors.length == 0) {
+      return parserErrors;
+    } else if (parserErrors.length == 0) {
+      return resolverErrors;
+    } else {
+      List<AnalysisError> allErrors = new List<AnalysisError>.fixedLength(parserErrors.length + resolverErrors.length);
+      System.arraycopy(parserErrors, 0, allErrors, 0, parserErrors.length);
+      System.arraycopy(resolverErrors, 0, allErrors, parserErrors.length, resolverErrors.length);
+      return allErrors;
+    }
   }
   int get length {
-    Token endToken4 = endToken;
-    if (endToken4 == null) {
+    Token endToken3 = endToken;
+    if (endToken3 == null) {
       return 0;
     }
-    return endToken4.offset + endToken4.length - beginToken.offset;
+    return endToken3.offset + endToken3.length - beginToken.offset;
   }
+  /**
+   * Get the {@link LineInfo} object for this compilation unit.
+   * @return the associated {@link LineInfo}
+   */
+  LineInfo get lineInfo => _lineInfo;
   int get offset {
     Token beginToken4 = beginToken;
     if (beginToken4 == null) {
       return 0;
     }
     return beginToken4.offset;
   }
   /**
+   * Return an array containing all of the parsing errors associated with the receiver.
+   * @return an array of errors (not {@code null}, contains no {@code null}s).
+   */
+  List<AnalysisError> get parsingErrors => _parsingErrors;
+  /**
+   * Return an array containing all of the resolution errors associated with the receiver. If the
+   * receiver has not been resolved, then return {@code null}.
+   * @return an array of errors (contains no {@code null}s) or {@code null} if the receiver has not
+   * been resolved
+   */
+  List<AnalysisError> get resolutionErrors => _resolutionErrors;
+  /**
    * Return the script tag at the beginning of the compilation unit, or {@code null} if there is no
    * script tag in this compilation unit.
    * @return the script tag at the beginning of the compilation unit
    */
   ScriptTag get scriptTag => _scriptTag;
   /**
-   * Return an array containing all of the semantic errors associated with the receiver. If the
-   * receiver has not been resolved, then return {@code null}.
-   * @return an array of errors (contains no {@code null}s) or {@code null} if the receiver has not
-   * been resolved
-   */
-  List<AnalysisError> get semanticErrors {
-    throw new UnsupportedOperationException();
-  }
-  /**
-   * Return an array containing all of the syntactic errors associated with the receiver.
-   * @return an array of errors (not {@code null}, contains no {@code null}s).
-   */
-  List<AnalysisError> get syntacticErrors => _syntacticErrors;
-  /**
    * Set the element associated with this compilation unit to the given element.
    * @param element the element associated with this compilation unit
    */
-  void set element4(CompilationUnitElement element) {
-    this._element = element;
+  void set element(CompilationUnitElement element5) {
+    this._element = element5;
+  }
+  /**
+   * Set the {@link LineInfo} object for this compilation unit.
+   * @param errors LineInfo to associate with this compilation unit
+   */
+  void set lineInfo(LineInfo lineInfo2) {
+    this._lineInfo = lineInfo2;
+  }
+  /**
+   * Called to cache the parsing errors when the unit is parsed.
+   * @param errors an array of parsing errors, if <code>null</code> is passed, the error array is
+   * set to an empty array, {@link AnalysisError#NO_ERRORS}
+   */
+  void set parsingErrors(List<AnalysisError> errors) {
+    _parsingErrors = errors == null ? AnalysisError.NO_ERRORS : errors;
+  }
+  /**
+   * Called to cache the resolution errors when the unit is resolved.
+   * @param errors an array of resolution errors, if <code>null</code> is passed, the error array is
+   * set to an empty array, {@link AnalysisError#NO_ERRORS}
+   */
+  void set resolutionErrors(List<AnalysisError> errors) {
+    _resolutionErrors = errors == null ? AnalysisError.NO_ERRORS : errors;
   }
   /**
    * Set the script tag at the beginning of the compilation unit to the given script tag.
    * @param scriptTag the script tag at the beginning of the compilation unit
    */
-  void set scriptTag2(ScriptTag scriptTag) {
-    this._scriptTag = becomeParentOf(scriptTag);
-  }
-  /**
-   * Called by the {@link AnalysisContext} to cache the syntax errors when the unit is parsed.
-   * @param errors an array of syntax errors (not {@code null}, contains no {@code null}s)
-   */
-  void set syntacticErrors2(List<AnalysisError> errors) {
-    this._syntacticErrors = errors;
+  void set scriptTag(ScriptTag scriptTag2) {
+    this._scriptTag = becomeParentOf(scriptTag2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_scriptTag, visitor);
     if (directivesAreBeforeDeclarations()) {
       _directives.accept(visitor);
       _declarations.accept(visitor);
     } else {
       for (ASTNode child in sortedDirectivesAndDeclarations) {
         child.accept(visitor);
       }
@@ skipping 31 matching lines @@
  * declare a name within the scope of a compilation unit.
  * <pre>
  * compilationUnitMember ::={@link ClassDeclaration classDeclaration}| {@link TypeAlias typeAlias}| {@link FunctionDeclaration functionDeclaration}| {@link MethodDeclaration getOrSetDeclaration}| {@link VariableDeclaration constantsDeclaration}| {@link VariableDeclaration variablesDeclaration}</pre>
  */
 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(Comment comment, List<Annotation> metadata) : super(comment, metadata) {
+  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);
 }
 /**
  * Instances of the class {@code ConditionalExpression} represent a conditional expression.
  * <pre>
  * conditionalExpression ::={@link Expression condition} '?' {@link Expression thenExpression} ':' {@link Expression elseExpression}</pre>
  */
 class ConditionalExpression extends Expression {
   /**
    * The condition used to determine which of the expressions is executed next.
    */
@@ skipping 15 matching lines @@
    */
   Expression _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{@code 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{@code false}
    */
-  ConditionalExpression(Expression condition, Token question, Expression thenExpression, Token colon, Expression elseExpression) {
+  ConditionalExpression.full(Expression condition, Token question, Expression thenExpression, Token colon, Expression elseExpression) {
     this._condition = becomeParentOf(condition);
     this._question = question;
     this._thenExpression = becomeParentOf(thenExpression);
     this._colon = colon;
     this._elseExpression = becomeParentOf(elseExpression);
   }
+  /**
+   * 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{@code 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{@code 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 token used to separate the then expression from the else expression.
    * @return the token used to separate the then expression from the else expression
    */
   Token get colon => _colon;
   /**
    * Return the condition used to determine which of the expressions is executed next.
    * @return the condition used to determine which expression is executed next
@@ skipping 12 matching lines @@
   Token get question => _question;
   /**
    * Return the expression that is executed if the condition evaluates to {@code true}.
    * @return the expression that is executed if the condition evaluates to {@code true}
    */
   Expression get thenExpression => _thenExpression;
   /**
    * Set the token used to separate the then expression from the else expression to the given token.
    * @param colon the token used to separate the then expression from the else expression
    */
-  void set colon2(Token colon) {
-    this._colon = colon;
+  void set colon(Token colon2) {
+    this._colon = colon2;
   }
   /**
    * Set the condition used to determine which of the expressions is executed next to the given
    * expression.
    * @param expression the condition used to determine which expression is executed next
    */
-  void set condition3(Expression expression) {
+  void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
   /**
    * Set the expression that is executed if the condition evaluates to {@code false} to the given
    * expression.
    * @param expression the expression that is executed if the condition evaluates to {@code false}
    */
-  void set elseExpression2(Expression expression) {
+  void set elseExpression(Expression expression) {
     _elseExpression = becomeParentOf(expression);
   }
   /**
    * Set the token used to separate the condition from the then expression to the given token.
    * @param question the token used to separate the condition from the then expression
    */
-  void set question3(Token question) {
-    this._question = question;
+  void set question(Token question3) {
+    this._question = question3;
   }
   /**
    * Set the expression that is executed if the condition evaluates to {@code true} to the given
    * expression.
    * @param expression the expression that is executed if the condition evaluates to {@code true}
    */
-  void set thenExpression2(Expression expression) {
+  void set thenExpression(Expression expression) {
     _thenExpression = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_thenExpression, visitor);
     safelyVisitChild(_elseExpression, visitor);
   }
 }
 /**
  * Instances of the class {@code ConstructorDeclaration} represent a constructor declaration.
@@ skipping 75 matching lines @@
    * @param returnType the return type of the constructor
    * @param period the token for the period before the constructor name
    * @param name the name of the constructor
    * @param parameters the parameters associated with the constructor
    * @param separator the token for the colon or equals before the initializers
    * @param initializers the initializers associated with the constructor
    * @param redirectedConstructor the name of the constructor to which this constructor will be
    * redirected
    * @param body the body of the constructor
    */
-  ConstructorDeclaration(Comment comment, List<Annotation> metadata, Token externalKeyword, Token constKeyword, Token factoryKeyword, Identifier returnType, Token period, SimpleIdentifier name, FormalParameterList parameters, Token separator, List<ConstructorInitializer> initializers, ConstructorName redirectedConstructor, FunctionBody body) : super(comment, metadata) {
+  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;
     this._returnType = becomeParentOf(returnType);
     this._period = period;
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
     this._separator = separator;
     this._initializers.addAll(initializers);
     this._redirectedConstructor = becomeParentOf(redirectedConstructor);
     this._body = becomeParentOf(body);
   }
+  /**
+   * 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 {@code null} if the constructor does not have a body.
    * @return the body of the constructor
    */
   FunctionBody get body => _body;
   /**
    * Return the token for the 'const' keyword.
    * @return the token for the 'const' keyword
    */
@@ skipping 59 matching lines @@
   Identifier get returnType => _returnType;
   /**
    * Return the token for the separator (colon or equals) before the initializers, or {@code null}if there are no initializers.
    * @return the token for the separator (colon or equals) before the initializers
    */
   Token get separator => _separator;
   /**
    * Set the body of the constructor to the given function body.
    * @param functionBody the body of the constructor
    */
-  void set body3(FunctionBody functionBody) {
+  void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
   /**
    * Set the token for the 'const' keyword to the given token.
    * @param constKeyword the token for the 'const' keyword
    */
-  void set constKeyword2(Token constKeyword) {
-    this._constKeyword = constKeyword;
+  void set constKeyword(Token constKeyword2) {
+    this._constKeyword = constKeyword2;
   }
   /**
    * Set the element associated with this constructor to the given element.
    * @param element the element associated with this constructor
    */
-  void set element5(ConstructorElement element) {
-    this._element = element;
+  void set element(ConstructorElement element6) {
+    this._element = element6;
   }
   /**
    * Set the token for the 'external' keyword to the given token.
    * @param externalKeyword the token for the 'external' keyword
    */
-  void set externalKeyword2(Token externalKeyword) {
-    this._externalKeyword = externalKeyword;
+  void set externalKeyword(Token externalKeyword2) {
+    this._externalKeyword = externalKeyword2;
   }
   /**
    * Set the token for the 'factory' keyword to the given token.
    * @param factoryKeyword the token for the 'factory' keyword
    */
-  void set factoryKeyword2(Token factoryKeyword) {
-    this._factoryKeyword = factoryKeyword;
+  void set factoryKeyword(Token factoryKeyword2) {
+    this._factoryKeyword = factoryKeyword2;
   }
   /**
    * Set the name of the constructor to the given identifier.
    * @param identifier the name of the constructor
    */
-  void set name5(SimpleIdentifier identifier) {
+  void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
   /**
    * Set the parameters associated with the constructor to the given list of parameters.
    * @param parameters the parameters associated with the constructor
    */
-  void set parameters2(FormalParameterList parameters) {
-    this._parameters = becomeParentOf(parameters);
+  void set parameters(FormalParameterList parameters2) {
+    this._parameters = becomeParentOf(parameters2);
   }
   /**
    * Set the token for the period before the constructor name to the given token.
    * @param period the token for the period before the constructor name
    */
-  void set period3(Token period) {
-    this._period = period;
+  void set period(Token period3) {
+    this._period = period3;
   }
   /**
    * Set the name of the constructor to which this constructor will be redirected to the given
    * constructor name.
    * @param redirectedConstructor the name of the constructor to which this constructor will be
    * redirected
    */
-  void set redirectedConstructor2(ConstructorName redirectedConstructor) {
-    this._redirectedConstructor = becomeParentOf(redirectedConstructor);
+  void set redirectedConstructor(ConstructorName redirectedConstructor2) {
+    this._redirectedConstructor = becomeParentOf(redirectedConstructor2);
   }
   /**
    * Set the type of object being created to the given type name.
    * @param typeName the type of object being created
    */
-  void set returnType2(Identifier typeName) {
+  void set returnType(Identifier typeName) {
     _returnType = becomeParentOf(typeName);
   }
   /**
    * Set the token for the separator (colon or equals) before the initializers to the given token.
    * @param separator the token for the separator (colon or equals) before the initializers
    */
-  void set separator2(Token separator) {
-    this._separator = separator;
+  void set separator(Token separator2) {
+    this._separator = separator2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_parameters, visitor);
     _initializers.accept(visitor);
     safelyVisitChild(_body, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
@@ skipping 51 matching lines @@
   Expression _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) {
+  ConstructorFieldInitializer.full(Token keyword, Token period, SimpleIdentifier fieldName, Token equals, Expression expression) {
     this._keyword = keyword;
     this._period = period;
     this._fieldName = becomeParentOf(fieldName);
     this._equals = equals;
     this._expression = becomeParentOf(expression);
   }
+  /**
+   * 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;
   /**
    * Return the token for the equal sign between the field name and the expression.
@@ skipping 18 matching lines @@
   /**
    * Return the token for the period after the 'this' keyword, or {@code null} if there is no 'this'
    * keyword.
    * @return the token for the period after the 'this' keyword
    */
   Token get period => _period;
   /**
    * Set the token for the equal sign between the field name and the expression to the given token.
    * @param equals the token for the equal sign between the field name and the expression
    */
-  void set equals5(Token equals) {
-    this._equals = equals;
+  void set equals(Token equals5) {
+    this._equals = equals5;
   }
   /**
    * Set the expression computing the value to which the field will be initialized to the given
    * expression.
    * @param expression the expression computing the value to which the field will be initialized
    */
-  void set expression3(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression3) {
+    this._expression = becomeParentOf(expression3);
   }
   /**
    * Set the name of the field being initialized to the given identifier.
    * @param identifier the name of the field being initialized
    */
-  void set fieldName2(SimpleIdentifier identifier) {
+  void set fieldName(SimpleIdentifier identifier) {
     _fieldName = becomeParentOf(identifier);
   }
   /**
    * Set the token for the 'this' keyword to the given token.
    * @param keyword the token for the 'this' keyword
    */
-  void set keyword6(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword6) {
+    this._keyword = keyword6;
   }
   /**
    * Set the token for the period after the 'this' keyword to the given token.
    * @param period the token for the period after the 'this' keyword
    */
-  void set period4(Token period) {
-    this._period = period;
+  void set period(Token period4) {
+    this._period = period4;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_fieldName, visitor);
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ConstructorInitializer} defines the behavior of nodes that can
  * occur in the initializer list of a constructor declaration.
  * <pre>
@@ skipping 27 matching lines @@
    * The element associated with this constructor name, or {@code null} if the AST structure has not
    * been resolved or if this constructor name could not be resolved.
    */
   ConstructorElement _element;
   /**
    * 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) {
+  ConstructorName.full(TypeName type, Token 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;
   /**
    * Return the element associated with this constructor name, or {@code null} if the AST structure
    * has not been resolved or if this constructor name could not be resolved.
    * @return the element associated with this constructor name
    */
   ConstructorElement get element => _element;
   Token get endToken {
     if (_name != null) {
@@ skipping 15 matching lines @@
   Token get period => _period;
   /**
    * Return the name of the type defining the constructor.
    * @return the name of the type defining the constructor
    */
   TypeName get type => _type;
   /**
    * Set the element associated with this constructor name to the given element.
    * @param element the element associated with this constructor name
    */
-  void set element6(ConstructorElement element) {
-    this._element = element;
+  void set element(ConstructorElement element7) {
+    this._element = element7;
   }
   /**
    * Set the name of the constructor to the given name.
    * @param name the name of the constructor
    */
-  void set name6(SimpleIdentifier name) {
-    this._name = becomeParentOf(name);
+  void set name(SimpleIdentifier name4) {
+    this._name = becomeParentOf(name4);
   }
   /**
    * Return the token for the period before the constructor name to the given token.
    * @param period the token for the period before the constructor name
    */
-  void set period5(Token period) {
-    this._period = period;
+  void set period(Token period5) {
+    this._period = period5;
   }
   /**
    * Set the name of the type defining the constructor to the given type name.
    * @param type the name of the type defining the constructor
    */
-  void set type3(TypeName type) {
-    this._type = becomeParentOf(type);
+  void set type(TypeName type2) {
+    this._type = becomeParentOf(type2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_type, visitor);
     safelyVisitChild(_name, visitor);
   }
 }
 /**
  * Instances of the class {@code ContinueStatement} represent a continue statement.
  * <pre>
  * continueStatement ::=
@@ skipping 12 matching lines @@
   /**
    * The semicolon terminating the statement.
    */
   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(Token keyword, SimpleIdentifier label, Token semicolon) {
+  ContinueStatement.full(Token keyword, SimpleIdentifier label, Token semicolon) {
     this._keyword = keyword;
     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 token representing the 'continue' keyword.
    * @return the token representing the 'continue' keyword
    */
   Token get keyword => _keyword;
   /**
    * Return the label associated with the statement, or {@code null} if there is no label.
    * @return the label associated with the statement
    */
   SimpleIdentifier get label => _label;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the 'continue' keyword to the given token.
    * @param keyword the token representing the 'continue' keyword
    */
-  void set keyword7(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword7) {
+    this._keyword = keyword7;
   }
   /**
    * Set the label associated with the statement to the given label.
    * @param identifier the label associated with the statement
    */
-  void set label3(SimpleIdentifier identifier) {
+  void set label(SimpleIdentifier identifier) {
     _label = becomeParentOf(identifier);
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon4(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon4) {
+    this._semicolon = semicolon4;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
  * The abstract class {@code Declaration} defines the behavior common to nodes that represent the
  * declaration of a name. Each declared name is visible within a name scope.
  */
 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(Comment comment, List<Annotation> metadata) : super(comment, metadata) {
+  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);
 }
 /**
  * Instances of the class {@code 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 ::={@link NormalFormalParameter normalFormalParameter} ('=' {@link Expression defaultValue})?
  * defaultNamedParameter ::={@link NormalFormalParameter normalFormalParameter} (':' {@link Expression defaultValue})?
  * </pre>
  */
@@ skipping 16 matching lines @@
    * 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(NormalFormalParameter parameter, ParameterKind kind, Token separator, Expression defaultValue) {
+  DefaultFormalParameter.full(NormalFormalParameter parameter, ParameterKind kind, Token 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 {@code 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) {
@@ skipping 21 matching lines @@
   bool isConst() => _parameter != null && _parameter.isConst();
   /**
    * Return {@code true} if this parameter is a final parameter.
    * @return {@code true} if this parameter is a final parameter
    */
   bool 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 defaultValue2(Expression expression) {
+  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 kind2(ParameterKind kind) {
-    this._kind = kind;
+  void set kind(ParameterKind kind2) {
+    this._kind = kind2;
   }
   /**
    * 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 parameter2(NormalFormalParameter formalParameter) {
+  void set parameter(NormalFormalParameter formalParameter) {
     _parameter = becomeParentOf(formalParameter);
   }
   /**
    * Set the token separating the parameter from the default value to the given token.
    * @param separator the token separating the parameter from the default value
    */
-  void set separator3(Token separator) {
-    this._separator = separator;
+  void set separator(Token separator3) {
+    this._separator = separator3;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_parameter, visitor);
     safelyVisitChild(_defaultValue, visitor);
   }
 }
 /**
  * The abstract class {@code Directive} defines the behavior common to nodes that represent a
  * directive.
  * <pre>
  * directive ::={@link ExportDirective exportDirective}| {@link ImportDirective importDirective}| {@link LibraryDirective libraryDirective}| {@link PartDirective partDirective}| {@link PartOfDirective partOfDirective}</pre>
  */
 abstract class Directive extends AnnotatedNode {
   /**
    * The element associated with this directive, or {@code null} if the AST structure has not been
    * 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(Comment comment, List<Annotation> metadata) : super(comment, metadata) {
+  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);
+  /**
    * Return the element associated with this directive, or {@code 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;
   /**
    * Return the token representing the keyword that introduces this directive ('import', 'export',
    * 'library' or 'part').
    * @return the token representing the keyword that introduces this directive
    */
   Token get keyword;
   /**
    * Set the element associated with this directive to the given element.
    * @param element the element associated with this directive
    */
-  void set element7(Element element) {
-    this._element = element;
+  void set element(Element element8) {
+    this._element = element8;
   }
 }
 /**
  * Instances of the class {@code DoStatement} represent a do statement.
  * <pre>
  * doStatement ::=
  * 'do' {@link Statement body} 'while' '(' {@link Expression condition} ')' ';'
  * </pre>
  */
 class DoStatement extends Statement {
@@ skipping 28 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(Token doKeyword, Statement body, Token whileKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon) {
+  DoStatement.full(Token doKeyword, Statement body, Token whileKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Token semicolon) {
     this._doKeyword = doKeyword;
     this._body = becomeParentOf(body);
     this._whileKeyword = whileKeyword;
     this._leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
     this._rightParenthesis = rightParenthesis;
     this._semicolon = semicolon;
   }
+  /**
+   * 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;
   /**
    * Return the condition that determines when the loop will terminate.
    * @return the condition that determines when the loop will terminate
@@ skipping 22 matching lines @@
   Token get semicolon => _semicolon;
   /**
    * Return the token representing the 'while' keyword.
    * @return the token representing the 'while' keyword
    */
   Token get whileKeyword => _whileKeyword;
   /**
    * Set the body of the loop to the given statement.
    * @param statement the body of the loop
    */
-  void set body4(Statement statement) {
+  void set body(Statement statement) {
     _body = becomeParentOf(statement);
   }
   /**
    * Set the condition that determines when the loop will terminate to the given expression.
    * @param expression the condition that determines when the loop will terminate
    */
-  void set condition4(Expression expression) {
+  void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
   /**
    * Set the token representing the 'do' keyword to the given token.
    * @param doKeyword the token representing the 'do' keyword
    */
-  void set doKeyword2(Token doKeyword) {
-    this._doKeyword = doKeyword;
+  void set doKeyword(Token doKeyword2) {
+    this._doKeyword = doKeyword2;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param parenthesis the left parenthesis
    */
-  void set leftParenthesis5(Token parenthesis) {
+  void set leftParenthesis(Token parenthesis) {
     _leftParenthesis = parenthesis;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param parenthesis the right parenthesis
    */
-  void set rightParenthesis5(Token parenthesis) {
+  void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon5(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon5) {
+    this._semicolon = semicolon5;
   }
   /**
    * Set the token representing the 'while' keyword to the given token.
    * @param whileKeyword the token representing the 'while' keyword
    */
-  void set whileKeyword2(Token whileKeyword) {
-    this._whileKeyword = whileKeyword;
+  void set whileKeyword(Token whileKeyword2) {
+    this._whileKeyword = whileKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_body, visitor);
     safelyVisitChild(_condition, visitor);
   }
 }
 /**
  * Instances of the class {@code DoubleLiteral} represent a floating point literal expression.
  * <pre>
  * doubleLiteral ::=
@@ skipping 10 matching lines @@
   Token _literal;
   /**
    * 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(Token literal, double value) {
+  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);
   accept(ASTVisitor visitor) => visitor.visitDoubleLiteral(this);
   Token get beginToken => _literal;
   Token get endToken => _literal;
   /**
    * Return the token representing the literal.
    * @return the token representing the literal
    */
   Token get literal => _literal;
   /**
    * Return the value of the literal.
    * @return the value of the literal
    */
   double get value => _value;
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
-  void set literal3(Token literal) {
-    this._literal = literal;
+  void set literal(Token literal3) {
+    this._literal = literal3;
   }
   /**
    * Set the value of the literal to the given value.
    * @param value the value of the literal
    */
-  void set value5(double value) {
-    this._value = value;
+  void set value(double value5) {
+    this._value = value5;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code EmptyFunctionBody} represent an empty function body, which can only
  * appear in constructors or abstract methods.
  * <pre>
  * emptyFunctionBody ::=
  * ';'
  * </pre>
  */
 class EmptyFunctionBody extends FunctionBody {
   /**
    * 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(Token semicolon) {
+  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);
   accept(ASTVisitor visitor) => visitor.visitEmptyFunctionBody(this);
   Token get beginToken => _semicolon;
   Token get endToken => _semicolon;
   /**
    * Return the token representing the semicolon that marks the end of the function body.
    * @return the token representing the semicolon that marks the end of the function body
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the semicolon that marks the end of the function body to the given
    * token.
    * @param semicolon the token representing the semicolon that marks the end of the function body
    */
-  void set semicolon6(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon6) {
+    this._semicolon = semicolon6;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code EmptyStatement} represent an empty statement.
  * <pre>
  * emptyStatement ::=
  * ';'
  * </pre>
  */
 class EmptyStatement extends Statement {
   /**
    * The semicolon terminating the statement.
    */
   Token _semicolon;
   /**
    * Initialize a newly created empty statement.
    * @param semicolon the semicolon terminating the statement
    */
-  EmptyStatement(Token semicolon) {
+  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);
   accept(ASTVisitor visitor) => visitor.visitEmptyStatement(this);
   Token get beginToken => _semicolon;
   Token get endToken => _semicolon;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon7(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon7) {
+    this._semicolon = semicolon7;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ExportDirective} represent an export directive.
  * <pre>
  * exportDirective ::={@link Annotation metadata} 'export' {@link StringLiteral libraryUri} {@link Combinator combinator}* ';'
  * </pre>
  */
 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(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon) : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
+  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);
   accept(ASTVisitor visitor) => visitor.visitExportDirective(this);
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
-    safelyVisitChild(libraryUri, visitor);
     combinators.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code Expression} defines the behavior common to nodes that represent an
  * expression.
  * <pre>
  * expression ::={@link AssignmentExpression assignmentExpression}| {@link ConditionalExpression conditionalExpression} cascadeSection
  * | {@link ThrowExpression throwExpression}</pre>
  */
@@ skipping 21 matching lines @@
   Type2 get staticType => _staticType;
   /**
    * Return {@code true} if this expression is syntactically valid for the LHS of an{@link AssignmentExpression assignment expression}.
    * @return {@code true} if this expression matches the {@code assignableExpression} production
    */
   bool isAssignable() => false;
   /**
    * Set the propagated type of this expression to the given type.
    * @param propagatedType the propagated type of this expression
    */
-  void set propagatedType2(Type2 propagatedType) {
-    this._propagatedType = propagatedType;
+  void set propagatedType(Type2 propagatedType2) {
+    this._propagatedType = propagatedType2;
   }
   /**
    * Set the static type of this expression to the given type.
    * @param staticType the static type of this expression
    */
-  void set staticType2(Type2 staticType) {
-    this._staticType = staticType;
+  void set staticType(Type2 staticType2) {
+    this._staticType = staticType2;
   }
 }
 /**
  * Instances of the class {@code ExpressionFunctionBody} represent a function body consisting of a
  * single expression.
  * <pre>
  * expressionFunctionBody ::=
  * '=>' {@link Expression expression} ';'
  * </pre>
  */
@@ skipping 10 matching lines @@
    * The semicolon terminating the statement.
    */
   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(Token functionDefinition, Expression expression, Token semicolon) {
+  ExpressionFunctionBody.full(Token functionDefinition, Expression expression, Token semicolon) {
     this._functionDefinition = functionDefinition;
     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;
   }
   /**
    * Return the expression representing the body of the function.
    * @return the expression representing the body of the function
    */
   Expression get expression => _expression;
   /**
    * Return the token introducing the expression that represents the body of the function.
    * @return the function definition token
    */
   Token get functionDefinition => _functionDefinition;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * Set the expression representing the body of the function to the given expression.
    * @param expression the expression representing the body of the function
    */
-  void set expression4(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression4) {
+    this._expression = becomeParentOf(expression4);
   }
   /**
    * Set the token introducing the expression that represents the body of the function to the given
    * token.
    * @param functionDefinition the function definition token
    */
-  void set functionDefinition2(Token functionDefinition) {
-    this._functionDefinition = functionDefinition;
+  void set functionDefinition(Token functionDefinition2) {
+    this._functionDefinition = functionDefinition2;
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon8(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon8) {
+    this._semicolon = semicolon8;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ExpressionStatement} wrap an expression as a statement.
  * <pre>
  * expressionStatement ::={@link Expression expression}? ';'
  * </pre>
  */
 class ExpressionStatement extends Statement {
   /**
    * The expression that comprises the statement.
    */
   Expression _expression;
   /**
    * The semicolon terminating the statement, or {@code null} if the expression is a function
    * expression and isn't followed by a semicolon.
    */
   Token _semicolon;
   /**
    * Initialize a newly created expression statement.
    * @param expression the expression that comprises the statement
    * @param semicolon the semicolon terminating the statement
    */
-  ExpressionStatement(Expression expression, Token semicolon) {
+  ExpressionStatement.full(Expression expression, Token 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;
   }
   /**
    * Return the expression that comprises the statement.
    * @return the expression that comprises the statement
    */
   Expression get expression => _expression;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   bool isSynthetic() => _expression.isSynthetic() && _semicolon.isSynthetic();
   /**
    * Set the expression that comprises the statement to the given expression.
    * @param expression the expression that comprises the statement
    */
-  void set expression5(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression5) {
+    this._expression = becomeParentOf(expression5);
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon9(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon9) {
+    this._semicolon = semicolon9;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ExtendsClause} represent the "extends" clause in a class
  * declaration.
  * <pre>
  * extendsClause ::=
  * 'extends' {@link TypeName superclass}</pre>
  */
 class ExtendsClause extends ASTNode {
   /**
    * The token representing the 'extends' keyword.
    */
   Token _keyword;
   /**
    * 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(Token keyword, TypeName superclass) {
+  ExtendsClause.full(Token keyword, TypeName superclass) {
     this._keyword = keyword;
     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 token representing the 'extends' keyword.
    * @return the token representing the 'extends' keyword
    */
   Token get keyword => _keyword;
   /**
    * Return the name of the class that is being extended.
    * @return the name of the class that is being extended
    */
   TypeName get superclass => _superclass;
   /**
    * Set the token representing the 'extends' keyword to the given token.
    * @param keyword the token representing the 'extends' keyword
    */
-  void set keyword8(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword8) {
+    this._keyword = keyword8;
   }
   /**
    * Set the name of the class that is being extended to the given name.
    * @param name the name of the class that is being extended
    */
-  void set superclass3(TypeName name) {
+  void set superclass(TypeName name) {
     _superclass = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_superclass, visitor);
   }
 }
 /**
  * Instances of the class {@code FieldDeclaration} represent the declaration of one or more fields
  * of the same type.
  * <pre>
@@ skipping 15 matching lines @@
    */
   Token _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 keyword 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 keyword, VariableDeclarationList fieldList, Token semicolon) : super(comment, metadata) {
+  FieldDeclaration.full(Comment comment, List<Annotation> metadata, Token keyword, VariableDeclarationList fieldList, Token semicolon) : super.full(comment, metadata) {
     this._keyword = keyword;
     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 keyword 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 keyword, VariableDeclarationList fieldList, Token semicolon}) : this.full(comment, metadata, keyword, fieldList, semicolon);
   accept(ASTVisitor visitor) => visitor.visitFieldDeclaration(this);
   Token get endToken => _semicolon;
   /**
    * Return the fields being declared.
    * @return the fields being declared
    */
   VariableDeclarationList get fields => _fieldList;
   /**
    * Return the token representing the 'static' keyword, or {@code null} if the fields are not
    * static.
    * @return the token representing the 'static' keyword
    */
   Token get keyword => _keyword;
   /**
    * Return the semicolon terminating the declaration.
    * @return the semicolon terminating the declaration
    */
   Token get semicolon => _semicolon;
   /**
    * Set the fields being declared to the given list of variables.
    * @param fieldList the fields being declared
    */
-  void set fields2(VariableDeclarationList fieldList) {
+  void set fields(VariableDeclarationList fieldList) {
     fieldList = becomeParentOf(fieldList);
   }
   /**
    * Set the token representing the 'static' keyword to the given token.
    * @param keyword the token representing the 'static' keyword
    */
-  void set keyword9(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword9) {
+    this._keyword = keyword9;
   }
   /**
    * Set the semicolon terminating the declaration to the given token.
    * @param semicolon the semicolon terminating the declaration
    */
-  void set semicolon10(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon10) {
+    this._semicolon = semicolon10;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_fieldList, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_keyword != null) {
       return _keyword;
     }
     return _fieldList.beginToken;
@@ skipping 27 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 thisToken the token representing the 'this' keyword
    * @param period the token representing the period
    * @param identifier the name of the parameter being declared
    */
-  FieldFormalParameter(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, Token thisToken, Token period, SimpleIdentifier identifier) : super(comment, metadata, identifier) {
+  FieldFormalParameter.full(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, Token thisToken, Token period, SimpleIdentifier identifier) : super.full(comment, metadata, identifier) {
     this._keyword = keyword;
     this._type = becomeParentOf(type);
     this._thisToken = thisToken;
     this._period = period;
   }
+  /**
+   * 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
+   */
+  FieldFormalParameter({Comment comment, List<Annotation> metadata, Token keyword, TypeName type, Token thisToken, Token period, SimpleIdentifier identifier}) : this.full(comment, metadata, keyword, type, thisToken, period, identifier);
   accept(ASTVisitor visitor) => visitor.visitFieldFormalParameter(this);
   Token get beginToken {
     if (_keyword != null) {
       return _keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return _thisToken;
   }
   Token get endToken => identifier.endToken;
@@ skipping 11 matching lines @@
    * Return the token representing the 'this' keyword.
    * @return the token representing the 'this' keyword
    */
   Token get thisToken => _thisToken;
   /**
    * Return the name of the declared type of the parameter, or {@code null} if the parameter does
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
-  bool isConst() => (_keyword is KeywordToken) && (_keyword as KeywordToken).keyword == Keyword.CONST;
-  bool isFinal() => (_keyword is KeywordToken) && (_keyword as KeywordToken).keyword == Keyword.FINAL;
+  bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
+  bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
-  void set keyword10(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword10) {
+    this._keyword = keyword10;
   }
   /**
    * Set the token representing the period to the given token.
    * @param period the token representing the period
    */
-  void set period6(Token period) {
-    this._period = period;
+  void set period(Token period6) {
+    this._period = period6;
   }
   /**
    * Set the token representing the 'this' keyword to the given token.
    * @param thisToken the token representing the 'this' keyword
    */
-  void set thisToken2(Token thisToken) {
-    this._thisToken = thisToken;
+  void set thisToken(Token thisToken2) {
+    this._thisToken = thisToken2;
   }
   /**
    * Set the name of the declared type of the parameter to the given type name.
    * @param typeName the name of the declared type of the parameter
    */
-  void set type4(TypeName typeName) {
+  void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
   }
 }
 /**
  * Instances of the class {@code ForEachStatement} represent a for-each statement.
@@ skipping 32 matching lines @@
   Statement _body;
   /**
    * Initialize a newly created for-each statement.
    * @param forKeyword the token representing the 'for' keyword
    * @param leftParenthesis the left parenthesis
    * @param loopParameter 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(Token forKeyword, Token leftParenthesis, SimpleFormalParameter loopParameter, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body) {
+  ForEachStatement.full(Token forKeyword, Token leftParenthesis, SimpleFormalParameter loopParameter, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body) {
     this._forKeyword = forKeyword;
     this._leftParenthesis = leftParenthesis;
     this._loopParameter = becomeParentOf(loopParameter);
     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 loopParameter 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({Token forKeyword, Token leftParenthesis, SimpleFormalParameter loopParameter, Token inKeyword, Expression iterator, Token rightParenthesis, Statement body}) : this.full(forKeyword, leftParenthesis, loopParameter, 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;
   Token get endToken => _body.endToken;
   /**
    * Return the token representing the 'for' keyword.
@@ skipping 22 matching lines @@
   SimpleFormalParameter get loopParameter => _loopParameter;
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
   /**
    * Set the body of the loop to the given block.
    * @param body the body of the loop
    */
-  void set body5(Statement body) {
-    this._body = becomeParentOf(body);
+  void set body(Statement body2) {
+    this._body = becomeParentOf(body2);
   }
   /**
    * Set the token representing the 'for' keyword to the given token.
    * @param forKeyword the token representing the 'for' keyword
    */
-  void set forKeyword2(Token forKeyword) {
-    this._forKeyword = forKeyword;
+  void set forKeyword(Token forKeyword2) {
+    this._forKeyword = forKeyword2;
   }
   /**
    * Set the token representing the 'in' keyword to the given token.
    * @param inKeyword the token representing the 'in' keyword
    */
-  void set inKeyword2(Token inKeyword) {
-    this._inKeyword = inKeyword;
+  void set inKeyword(Token inKeyword2) {
+    this._inKeyword = inKeyword2;
   }
   /**
    * Set the expression evaluated to produce the iterator to the given expression.
    * @param expression the expression evaluated to produce the iterator
    */
-  void set iterator2(Expression expression) {
+  void set iterator(Expression expression) {
     _iterator = becomeParentOf(expression);
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
-  void set leftParenthesis6(Token leftParenthesis) {
-    this._leftParenthesis = leftParenthesis;
+  void set leftParenthesis(Token leftParenthesis3) {
+    this._leftParenthesis = leftParenthesis3;
   }
   /**
    * Set the declaration of the loop variable to the given parameter.
    * @param parameter the declaration of the loop variable
    */
-  void set loopParameter2(SimpleFormalParameter parameter) {
+  void set loopParameter(SimpleFormalParameter parameter) {
     _loopParameter = becomeParentOf(parameter);
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
-  void set rightParenthesis6(Token rightParenthesis) {
-    this._rightParenthesis = rightParenthesis;
+  void set rightParenthesis(Token rightParenthesis3) {
+    this._rightParenthesis = rightParenthesis3;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_loopParameter, visitor);
     safelyVisitChild(_iterator, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class {@code ForStatement} represent a for statement.
  * <pre>
@@ skipping 54 matching lines @@
    * @param leftParenthesis the left parenthesis
    * @param variableList the declaration of the loop variables
    * @param initialization the initialization expression
    * @param leftSeparator the semicolon separating the initializer and the condition
    * @param condition the condition used to determine when to terminate the loop
    * @param rightSeparator the semicolon separating the condition and the updater
    * @param updaters the list of expressions run after each execution of the loop body
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
-  ForStatement(Token forKeyword, Token leftParenthesis, VariableDeclarationList variableList, Expression initialization, Token leftSeparator, Expression condition, Token rightSeparator, List<Expression> updaters, Token rightParenthesis, Statement body) {
+  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;
     this._variableList = becomeParentOf(variableList);
     this._initialization = becomeParentOf(initialization);
     this._leftSeparator = leftSeparator;
     this._condition = becomeParentOf(condition);
     this._rightSeparator = rightSeparator;
     this._updaters.addAll(updaters);
     this._rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
+  /**
+   * 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.
    * @return the condition used to determine when to terminate the loop
@@ skipping 37 matching lines @@
   NodeList<Expression> get updaters => _updaters;
   /**
    * Return the declaration of the loop variables, or {@code null} if there are no variables.
    * @return the declaration of the loop variables, or {@code 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
    */
-  void set body6(Statement body) {
-    this._body = becomeParentOf(body);
+  void set body(Statement body3) {
+    this._body = becomeParentOf(body3);
   }
   /**
    * Set the condition used to determine when to terminate the loop to the given expression.
    * @param expression the condition used to determine when to terminate the loop
    */
-  void set condition5(Expression expression) {
+  void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
   /**
    * Set the token representing the 'for' keyword to the given token.
    * @param forKeyword the token representing the 'for' keyword
    */
-  void set forKeyword3(Token forKeyword) {
-    this._forKeyword = forKeyword;
+  void set forKeyword(Token forKeyword3) {
+    this._forKeyword = forKeyword3;
   }
   /**
    * Set the initialization expression to the given expression.
    * @param initialization the initialization expression
    */
-  void set initialization2(Expression initialization) {
-    this._initialization = becomeParentOf(initialization);
+  void set initialization(Expression initialization2) {
+    this._initialization = becomeParentOf(initialization2);
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
-  void set leftParenthesis7(Token leftParenthesis) {
-    this._leftParenthesis = leftParenthesis;
+  void set leftParenthesis(Token leftParenthesis4) {
+    this._leftParenthesis = leftParenthesis4;
   }
   /**
    * Set the semicolon separating the initializer and the condition to the given token.
    * @param leftSeparator the semicolon separating the initializer and the condition
    */
-  void set leftSeparator2(Token leftSeparator) {
-    this._leftSeparator = leftSeparator;
+  void set leftSeparator(Token leftSeparator2) {
+    this._leftSeparator = leftSeparator2;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
-  void set rightParenthesis7(Token rightParenthesis) {
-    this._rightParenthesis = rightParenthesis;
+  void set rightParenthesis(Token rightParenthesis4) {
+    this._rightParenthesis = rightParenthesis4;
   }
   /**
    * Set the semicolon separating the condition and the updater to the given token.
    * @param rightSeparator the semicolon separating the condition and the updater
    */
-  void set rightSeparator2(Token rightSeparator) {
-    this._rightSeparator = rightSeparator;
+  void set rightSeparator(Token rightSeparator2) {
+    this._rightSeparator = rightSeparator2;
   }
   /**
    * Set the declaration of the loop variables to the given parameter.
    * @param variableList the declaration of the loop variables
    */
-  void set variables2(VariableDeclarationList variableList) {
+  void set variables(VariableDeclarationList variableList) {
     variableList = becomeParentOf(variableList);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_variableList, visitor);
     safelyVisitChild(_initialization, visitor);
     safelyVisitChild(_condition, visitor);
     _updaters.accept(visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * The abstract class {@code FormalParameter} defines the behavior of objects representing a
  * parameter to a function.
  * <pre>
  * formalParameter ::={@link NormalFormalParameter normalFormalParameter}| {@link DefaultFormalParameter namedFormalParameter}| {@link DefaultFormalParameter optionalFormalParameter}</pre>
  */
 abstract class FormalParameter extends ASTNode {
   /**
    * Return the element representing this parameter, or {@code null} if this parameter has not been
    * resolved.
    * @return the element representing this parameter
    */
   ParameterElement get element {
-    SimpleIdentifier identifier6 = identifier;
-    if (identifier6 == null) {
+    SimpleIdentifier identifier9 = identifier;
+    if (identifier9 == null) {
       return null;
     }
-    return identifier6.element as ParameterElement;
+    return (identifier9.element as ParameterElement);
   }
   /**
    * Return the name of the parameter being declared.
    * @return the name of the parameter being declared
    */
   SimpleIdentifier get identifier;
   /**
    * Return the kind of this parameter.
    * @return the kind of this parameter
    */
@@ skipping 44 matching lines @@
    */
   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(Token leftParenthesis, List<FormalParameter> parameters, Token leftDelimiter, Token rightDelimiter, Token rightParenthesis) {
+  FormalParameterList.full(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._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;
   /**
    * Return an array containing the elements representing the parameters in this list. The array
    * will contain {@code null}s if the parameters in this list have not been resolved.
    * @return the elements representing the parameters in this list
    */
   List<ParameterElement> get elements {
     int count = _parameters.length;
     List<ParameterElement> types = new List<ParameterElement>.fixedLength(count);
@@ skipping 30 matching lines @@
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
   /**
    * Set the left square bracket ('[') or left curly brace ('{') introducing the optional parameters
    * to the given token.
    * @param bracket the left delimiter introducing the optional parameters
    */
-  void set leftDelimiter2(Token bracket) {
+  void set leftDelimiter(Token bracket) {
     _leftDelimiter = bracket;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param parenthesis the left parenthesis
    */
-  void set leftParenthesis8(Token parenthesis) {
+  void set leftParenthesis(Token parenthesis) {
     _leftParenthesis = parenthesis;
   }
   /**
    * Set the right square bracket (']') or right curly brace ('}') introducing the optional
    * parameters to the given token.
    * @param bracket the right delimiter introducing the optional parameters
    */
-  void set rightDelimiter2(Token bracket) {
+  void set rightDelimiter(Token bracket) {
     _rightDelimiter = bracket;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param parenthesis the right parenthesis
    */
-  void set rightParenthesis8(Token parenthesis) {
+  void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _parameters.accept(visitor);
   }
 }
 /**
  * The abstract class {@code FunctionBody} defines the behavior common to objects representing the
  * body of a function or method.
  * <pre>
@@ skipping 35 matching lines @@
   /**
    * Initialize a newly created function declaration.
    * @param comment the documentation comment associated with this function
    * @param metadata the annotations associated with this function
    * @param externalKeyword the token representing the 'external' keyword
    * @param returnType the return type of the function
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param name the name of the function
    * @param functionExpression the function expression being wrapped
    */
-  FunctionDeclaration(Comment comment, List<Annotation> metadata, Token externalKeyword, TypeName returnType, Token propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression) : super(comment, metadata) {
+  FunctionDeclaration.full(Comment comment, List<Annotation> metadata, Token externalKeyword, TypeName returnType, Token propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression) : super.full(comment, metadata) {
     this._externalKeyword = externalKeyword;
     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);
   /**
    * Return the {@link FunctionElement} associated with this function, or {@code null} if the AST
    * structure has not been resolved.
    * @return the {@link FunctionElement} associated with this function
    */
-  FunctionElement get element => _name != null ? _name.element as FunctionElement : null;
+  FunctionElement get element => _name != null ? (_name.element as FunctionElement) : null;
   Token get endToken => _functionExpression.endToken;
   /**
    * Return the token representing the 'external' keyword, or {@code null} if this is not an
    * external function.
    * @return the token representing the 'external' keyword
    */
   Token get externalKeyword => _externalKeyword;
   /**
    * Return the function expression being wrapped.
    * @return the function expression being wrapped
@@ skipping 12 matching lines @@
   Token get propertyKeyword => _propertyKeyword;
   /**
    * Return the return type of the function, or {@code null} if no return type was declared.
    * @return the return type of the function
    */
   TypeName get returnType => _returnType;
   /**
    * Set the token representing the 'external' keyword to the given token.
    * @param externalKeyword the token representing the 'external' keyword
    */
-  void set externalKeyword3(Token externalKeyword) {
-    this._externalKeyword = externalKeyword;
+  void set externalKeyword(Token externalKeyword3) {
+    this._externalKeyword = externalKeyword3;
   }
   /**
    * Set the function expression being wrapped to the given function expression.
    * @param functionExpression the function expression being wrapped
    */
-  void set functionExpression2(FunctionExpression functionExpression) {
-    functionExpression = becomeParentOf(functionExpression);
+  void set functionExpression(FunctionExpression functionExpression3) {
+    functionExpression3 = becomeParentOf(functionExpression3);
   }
   /**
    * Set the name of the function to the given identifier.
    * @param identifier the name of the function
    */
-  void set name7(SimpleIdentifier identifier) {
+  void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
   /**
    * Set the token representing the 'get' or 'set' keyword to the given token.
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    */
-  void set propertyKeyword2(Token propertyKeyword) {
-    this._propertyKeyword = propertyKeyword;
+  void set propertyKeyword(Token propertyKeyword2) {
+    this._propertyKeyword = propertyKeyword2;
   }
   /**
    * Set the return type of the function to the given name.
    * @param name the return type of the function
    */
-  void set returnType3(TypeName name) {
+  void set returnType(TypeName name) {
     _returnType = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_functionExpression, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_externalKeyword != null) {
@@ skipping 14 matching lines @@
  */
 class FunctionDeclarationStatement extends Statement {
   /**
    * The function declaration being wrapped.
    */
   FunctionDeclaration _functionDeclaration;
   /**
    * Initialize a newly created function declaration statement.
    * @param functionDeclaration the the function declaration being wrapped
    */
-  FunctionDeclarationStatement(FunctionDeclaration functionDeclaration) {
+  FunctionDeclarationStatement.full(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 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);
+  void set functionExpression(FunctionDeclaration functionDeclaration2) {
+    this._functionDeclaration = becomeParentOf(functionDeclaration2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_functionDeclaration, visitor);
   }
 }
 /**
  * Instances of the class {@code FunctionExpression} represent a function expression.
  * <pre>
  * functionExpression ::={@link FormalParameterList formalParameterList} {@link FunctionBody functionBody}</pre>
  */
 class FunctionExpression extends Expression {
   /**
    * The parameters associated with the function.
    */
   FormalParameterList _parameters;
   /**
    * The body of the function, or {@code null} if this is an external function.
    */
   FunctionBody _body;
   /**
    * The element associated with the function, or {@code null} if the AST structure has not been
    * 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(FormalParameterList parameters, FunctionBody body) {
+  FunctionExpression.full(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 17 matching lines @@
   }
   /**
    * Return the parameters associated with the function.
    * @return the parameters associated with the function
    */
   FormalParameterList get parameters => _parameters;
   /**
    * Set the body of the function to the given function body.
    * @param functionBody the body of the function
    */
-  void set body7(FunctionBody functionBody) {
+  void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
   /**
    * Set the element associated with this function to the given element.
    * @param element the element associated with this function
    */
-  void set element8(ExecutableElement element) {
-    this._element = element;
+  void set element(ExecutableElement element9) {
+    this._element = element9;
   }
   /**
    * Set the parameters associated with the function to the given list of parameters.
    * @param parameters the parameters associated with the function
    */
-  void set parameters3(FormalParameterList parameters) {
-    this._parameters = becomeParentOf(parameters);
+  void set parameters(FormalParameterList parameters3) {
+    this._parameters = becomeParentOf(parameters3);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_parameters, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class {@code FunctionExpressionInvocation} represent the invocation of a
  * function resulting from evaluating an expression. Invocations of methods and other forms of
  * functions are represented by {@link MethodInvocation method invocation} nodes. Invocations of
@@ skipping 13 matching lines @@
   /**
    * The element associated with the function being invoked, or {@code null} if the AST structure
    * has not been resolved or the function could not be resolved.
    */
   ExecutableElement _element;
   /**
    * 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) {
+  FunctionExpressionInvocation.full(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;
   /**
    * Return the element associated with the function being invoked, or {@code null} if the AST
    * structure has not been resolved or the function could not be resolved. One common example of
    * the latter case is an expression whose value can change over time.
    * @return the element associated with the function being invoked
    */
   ExecutableElement get element => _element;
   Token get endToken => _argumentList.endToken;
   /**
    * Return the expression producing the function being invoked.
    * @return the expression producing the function being invoked
    */
   Expression get function => _function;
   /**
    * Set the list of arguments to the method to the given list.
    * @param argumentList the list of arguments to the method
    */
-  void set argumentList5(ArgumentList argumentList) {
-    this._argumentList = becomeParentOf(argumentList);
+  void set argumentList(ArgumentList argumentList5) {
+    this._argumentList = becomeParentOf(argumentList5);
   }
   /**
    * Set the element associated with the function being invoked to the given element.
    * @param element the element associated with the function being invoked
    */
-  void set element9(ExecutableElement element) {
-    this._element = element;
+  void set element(ExecutableElement element10) {
+    this._element = element10;
   }
   /**
    * Set the expression producing the function being invoked to the given expression.
    * @param function the expression producing the function being invoked
    */
-  void set function2(Expression function) {
-    function = becomeParentOf(function);
+  void set function(Expression function2) {
+    function2 = becomeParentOf(function2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_function, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code FunctionTypeAlias} represent a function type alias.
  * <pre>
  * functionTypeAlias ::=
@@ skipping 23 matching lines @@
    * 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) : super(comment, metadata, keyword, semicolon) {
+  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) {
     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);
   /**
    * Return the {@link TypeAliasElement} associated with this type alias, or {@code null} if the AST
    * structure has not been resolved.
    * @return the {@link TypeAliasElement} associated with this type alias
    */
-  TypeAliasElement get element => _name != null ? _name.element as TypeAliasElement : null;
+  TypeAliasElement get element => _name != null ? (_name.element as TypeAliasElement) : null;
   /**
    * Return the name of the function type being declared.
    * @return the name of the function type being declared
    */
   SimpleIdentifier get name => _name;
   /**
    * Return the parameters associated with the function type.
    * @return the parameters associated with the function type
    */
   FormalParameterList get parameters => _parameters;
   /**
    * Return the name of the return type of the function type being defined, or {@code null} if no
    * return type was given.
    * @return the name of the return type of the function type being defined
    */
   TypeName get returnType => _returnType;
   /**
    * Return the type parameters for the function type, or {@code null} if the function type does not
    * have any type parameters.
    * @return the type parameters for the function type
    */
   TypeParameterList get typeParameters => _typeParameters;
   /**
    * Set the name of the function type being declared to the given identifier.
    * @param name the name of the function type being declared
    */
-  void set name8(SimpleIdentifier name) {
-    this._name = becomeParentOf(name);
+  void set name(SimpleIdentifier name5) {
+    this._name = becomeParentOf(name5);
   }
   /**
    * Set the parameters associated with the function type to the given list of parameters.
    * @param parameters the parameters associated with the function type
    */
-  void set parameters4(FormalParameterList parameters) {
-    this._parameters = becomeParentOf(parameters);
+  void set parameters(FormalParameterList parameters4) {
+    this._parameters = becomeParentOf(parameters4);
   }
   /**
    * Set the name of the return type of the function type being defined to the given type name.
    * @param typeName the name of the return type of the function type being defined
    */
-  void set returnType4(TypeName typeName) {
+  void set returnType(TypeName typeName) {
     _returnType = becomeParentOf(typeName);
   }
   /**
    * Set the type parameters for the function type to the given list of parameters.
    * @param typeParameters the type parameters for the function type
    */
-  void set typeParameters4(TypeParameterList typeParameters) {
-    this._typeParameters = becomeParentOf(typeParameters);
+  void set typeParameters(TypeParameterList typeParameters4) {
+    this._typeParameters = becomeParentOf(typeParameters4);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 /**
@@ skipping 13 matching lines @@
   FormalParameterList _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 {@code 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) : super(comment, metadata, identifier) {
+  FunctionTypedFormalParameter.full(Comment comment, List<Annotation> metadata, TypeName returnType, SimpleIdentifier identifier, FormalParameterList parameters) : super.full(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 {@code 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;
   /**
    * Return the parameters of the function-typed parameter.
    * @return the parameters of the function-typed parameter
    */
   FormalParameterList get parameters => _parameters;
   /**
    * Return the return type of the function, or {@code null} if the function does not have a return
    * type.
    * @return the return type of the function
    */
   TypeName get returnType => _returnType;
   bool isConst() => false;
   bool isFinal() => false;
   /**
    * Set the parameters of the function-typed parameter to the given parameters.
    * @param parameters the parameters of the function-typed parameter
    */
-  void set parameters5(FormalParameterList parameters) {
-    this._parameters = becomeParentOf(parameters);
+  void set parameters(FormalParameterList parameters5) {
+    this._parameters = becomeParentOf(parameters5);
   }
   /**
    * Set the return type of the function to the given type.
    * @param returnType the return type of the function
    */
-  void set returnType5(TypeName returnType) {
-    this._returnType = becomeParentOf(returnType);
+  void set returnType(TypeName returnType2) {
+    this._returnType = becomeParentOf(returnType2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(identifier, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 /**
  * Instances of the class {@code HideCombinator} represent a combinator that restricts the names
  * being imported to those that are not in a given list.
  * <pre>
  * hideCombinator ::=
  * 'hide' {@link SimpleIdentifier identifier} (',' {@link SimpleIdentifier identifier})
  * </pre>
  */
 class HideCombinator extends Combinator {
   /**
    * The list of names from the library that are hidden by this combinator.
    */
   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(Token keyword, List<SimpleIdentifier> hiddenNames) : super(keyword) {
+  HideCombinator.full(Token keyword, List<SimpleIdentifier> hiddenNames) : super.full(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;
   /**
    * 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<Object> visitor) {
     _hiddenNames.accept(visitor);
   }
@@ skipping 27 matching lines @@
   /**
    * Return the lexical representation of the identifier.
    * @return the lexical representation of the identifier
    */
   String get name;
   bool isAssignable() => true;
   /**
    * Set the element associated with this identifier to the given element.
    * @param element the element associated with this identifier
    */
-  void set element10(Element element) {
-    this._element = element;
+  void set element(Element element11) {
+    this._element = element11;
   }
 }
 /**
  * Instances of the class {@code IfStatement} represent an if statement.
  * <pre>
  * ifStatement ::=
  * 'if' '(' {@link Expression expression} ')' {@link Statement thenStatement} ('else' {@link Statement elseStatement})?
  * </pre>
  */
 class IfStatement extends Statement {
@@ skipping 29 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 {@code true}
    * @param elseKeyword the token representing the 'else' keyword
    * @param elseStatement the statement that is executed if the condition evaluates to {@code false}
    */
-  IfStatement(Token ifKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Statement thenStatement, Token elseKeyword, Statement elseStatement) {
+  IfStatement.full(Token ifKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Statement thenStatement, Token elseKeyword, Statement elseStatement) {
     this._ifKeyword = ifKeyword;
     this._leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
     this._rightParenthesis = rightParenthesis;
     this._thenStatement = becomeParentOf(thenStatement);
     this._elseKeyword = elseKeyword;
     this._elseStatement = becomeParentOf(elseStatement);
   }
+  /**
+   * 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 {@code true}
+   * @param elseKeyword the token representing the 'else' keyword
+   * @param elseStatement the statement that is executed if the condition evaluates to {@code 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;
   /**
    * Return the token representing the 'else' keyword.
    * @return the token representing the 'else' keyword
@@ skipping 28 matching lines @@
   /**
    * Return the statement that is executed if the condition evaluates to {@code true}.
    * @return the statement that is executed if the condition evaluates to {@code true}
    */
   Statement get thenStatement => _thenStatement;
   /**
    * Set the condition used to determine which of the statements is executed next to the given
    * expression.
    * @param expression the condition used to determine which statement is executed next
    */
-  void set condition6(Expression expression) {
+  void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
   /**
    * Set the token representing the 'else' keyword to the given token.
    * @param elseKeyword the token representing the 'else' keyword
    */
-  void set elseKeyword2(Token elseKeyword) {
-    this._elseKeyword = elseKeyword;
+  void set elseKeyword(Token elseKeyword2) {
+    this._elseKeyword = elseKeyword2;
   }
   /**
    * Set the statement that is executed if the condition evaluates to {@code false} to the given
    * statement.
    * @param statement the statement that is executed if the condition evaluates to {@code false}
    */
-  void set elseStatement2(Statement statement) {
+  void set elseStatement(Statement statement) {
     _elseStatement = becomeParentOf(statement);
   }
   /**
    * Set the token representing the 'if' keyword to the given token.
    * @param ifKeyword the token representing the 'if' keyword
    */
-  void set ifKeyword2(Token ifKeyword) {
-    this._ifKeyword = ifKeyword;
+  void set ifKeyword(Token ifKeyword2) {
+    this._ifKeyword = ifKeyword2;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
-  void set leftParenthesis9(Token leftParenthesis) {
-    this._leftParenthesis = leftParenthesis;
+  void set leftParenthesis(Token leftParenthesis5) {
+    this._leftParenthesis = leftParenthesis5;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
-  void set rightParenthesis9(Token rightParenthesis) {
-    this._rightParenthesis = rightParenthesis;
+  void set rightParenthesis(Token rightParenthesis5) {
+    this._rightParenthesis = rightParenthesis5;
   }
   /**
    * Set the statement that is executed if the condition evaluates to {@code true} to the given
    * statement.
    * @param statement the statement that is executed if the condition evaluates to {@code true}
    */
-  void set thenStatement2(Statement statement) {
+  void set thenStatement(Statement statement) {
     _thenStatement = becomeParentOf(statement);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_thenStatement, visitor);
     safelyVisitChild(_elseStatement, visitor);
   }
 }
 /**
  * Instances of the class {@code ImplementsClause} represent the "implements" clause in an class
@@ skipping 10 matching lines @@
   Token _keyword;
   /**
    * The interfaces that are being implemented.
    */
   NodeList<TypeName> _interfaces;
   /**
    * Initialize a newly created extends clause.
    * @param keyword the token representing the 'implements' keyword
    * @param interfaces the interfaces that are being implemented
    */
-  ImplementsClause(Token keyword, List<TypeName> interfaces) {
+  ImplementsClause.full(Token keyword, List<TypeName> interfaces) {
     this._interfaces = new NodeList<TypeName>(this);
     this._keyword = keyword;
     this._interfaces.addAll(interfaces);
   }
+  /**
+   * Initialize a newly created extends 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;
   /**
    * 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;
   /**
    * Return the token representing the 'implements' keyword.
    * @return the token representing the 'implements' keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the 'implements' keyword to the given token.
    * @param keyword the token representing the 'implements' keyword
    */
-  void set keyword11(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword11) {
+    this._keyword = keyword11;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _interfaces.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code ImportDirective} represent an import directive.
  * <pre>
  * importDirective ::={@link Annotation metadata} 'import' {@link StringLiteral libraryUri} ('as' identifier)? {@link Combinator combinator}* ';'
  * </pre>
@@ skipping 12 matching lines @@
    * 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) : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
+  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;
     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);
   /**
    * Return the token representing the 'as' token, or {@code null} if the imported names are not
    * prefixed.
    * @return the token representing the 'as' token
    */
   Token get asToken => _asToken;
   /**
    * Return the prefix to be used with the imported names, or {@code null} if the imported names are
    * not prefixed.
    * @return the prefix to be used with the imported names
    */
   SimpleIdentifier get prefix => _prefix;
   /**
    * Set the token representing the 'as' token to the given token.
    * @param asToken the token representing the 'as' token
    */
-  void set asToken2(Token asToken) {
-    this._asToken = asToken;
+  void set asToken(Token asToken2) {
+    this._asToken = asToken2;
   }
   /**
    * Set the prefix to be used with the imported names to the given identifier.
    * @param prefix the prefix to be used with the imported names
    */
-  void set prefix2(SimpleIdentifier prefix) {
-    this._prefix = becomeParentOf(prefix);
+  void set prefix(SimpleIdentifier prefix2) {
+    this._prefix = becomeParentOf(prefix2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
-    safelyVisitChild(libraryUri, visitor);
     safelyVisitChild(_prefix, visitor);
     combinators.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code IndexExpression} represent an index expression.
  * <pre>
  * indexExpression ::={@link Expression target} '[' {@link Expression index} ']'
  * </pre>
  */
@@ skipping 25 matching lines @@
    * resolved or if the operator could not be resolved.
    */
   MethodElement _element;
   /**
    * 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.con1(Expression target, Token leftBracket, Expression index, Token rightBracket) {
-    _jtd_constructor_55_impl(target, leftBracket, index, rightBracket);
-  }
-  _jtd_constructor_55_impl(Expression target, Token leftBracket, Expression index, Token rightBracket) {
-    this._target = becomeParentOf(target);
-    this._leftBracket = leftBracket;
-    this._index = becomeParentOf(index);
-    this._rightBracket = rightBracket;
+  IndexExpression.forTarget_full(Expression target3, Token leftBracket4, Expression index2, Token rightBracket4) {
+    _jtd_constructor_56_impl(target3, leftBracket4, index2, rightBracket4);
   }
   /**
    * 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 target3, Token leftBracket4, Expression index2, Token rightBracket4}) : this.forTarget_full(target3, leftBracket4, index2, rightBracket4);
+  _jtd_constructor_56_impl(Expression target3, Token leftBracket4, Expression index2, Token rightBracket4) {
+    this._target = becomeParentOf(target3);
+    this._leftBracket = leftBracket4;
+    this._index = becomeParentOf(index2);
+    this._rightBracket = rightBracket4;
+  }
+  /**
+   * 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.con2(Token period, Token leftBracket, Expression index, Token rightBracket) {
-    _jtd_constructor_56_impl(period, leftBracket, index, rightBracket);
+  IndexExpression.forCascade_full(Token period7, Token leftBracket5, Expression index3, Token rightBracket5) {
+    _jtd_constructor_57_impl(period7, leftBracket5, index3, rightBracket5);
   }
-  _jtd_constructor_56_impl(Token period, Token leftBracket, Expression index, Token rightBracket) {
-    this._period = period;
-    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 period7, Token leftBracket5, Expression index3, Token rightBracket5}) : this.forCascade_full(period7, leftBracket5, index3, rightBracket5);
+  _jtd_constructor_57_impl(Token period7, Token leftBracket5, Expression index3, Token rightBracket5) {
+    this._period = period7;
+    this._leftBracket = leftBracket5;
+    this._index = becomeParentOf(index3);
+    this._rightBracket = rightBracket5;
   }
   accept(ASTVisitor visitor) => visitor.visitIndexExpression(this);
   /**
    * Return the expression used to compute the object being indexed, or {@code null} if this index
    * expression is part of a cascade expression.
    * @return the expression used to compute the object being indexed
    * @see #getRealTarget()
    */
   Expression get array => _target;
   Token get beginToken {
@@ skipping 36 matching lines @@
    */
   Expression get realTarget {
     if (isCascaded()) {
       ASTNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
-      return (ancestor as CascadeExpression).target;
+      return ((ancestor as CascadeExpression)).target;
     }
     return _target;
   }
   /**
    * Return the right square bracket.
    * @return the right square bracket
    */
   Token get rightBracket => _rightBracket;
   /**
    * Return {@code true} if this expression is computing a right-hand value.
    * <p>
    * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
    * @return {@code true} if this expression is in a context where the operator '[]' will be invoked
    */
   bool inGetterContext() {
-    ASTNode parent4 = parent;
-    if (parent4 is AssignmentExpression) {
-      AssignmentExpression assignment = parent4 as AssignmentExpression;
-      if (assignment.leftHandSide == this && assignment.operator.type == TokenType.EQ) {
+    ASTNode parent3 = parent;
+    if (parent3 is AssignmentExpression) {
+      AssignmentExpression assignment = (parent3 as AssignmentExpression);
+      if (identical(assignment.leftHandSide, this) && identical(assignment.operator.type, TokenType.EQ)) {
         return false;
       }
     }
     return true;
   }
   /**
    * Return {@code true} if this expression is computing a left-hand value.
    * <p>
    * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
    * @return {@code true} if this expression is in a context where the operator '[]=' will be
    * invoked
    */
   bool inSetterContext() {
-    ASTNode parent5 = parent;
-    if (parent5 is PrefixExpression) {
-      return (parent5 as PrefixExpression).operator.type.isIncrementOperator();
-    } else if (parent5 is PostfixExpression) {
+    ASTNode parent4 = parent;
+    if (parent4 is PrefixExpression) {
+      return ((parent4 as PrefixExpression)).operator.type.isIncrementOperator();
+    } else if (parent4 is PostfixExpression) {
       return true;
-    } else if (parent5 is AssignmentExpression) {
-      return (parent5 as AssignmentExpression).leftHandSide == this;
+    } else if (parent4 is AssignmentExpression) {
+      return identical(((parent4 as AssignmentExpression)).leftHandSide, this);
     }
     return false;
   }
   bool isAssignable() => true;
   /**
    * Return {@code true} if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a{@link CascadeExpression}.
    * @return {@code true} if this expression is cascaded
    */
   bool isCascaded() => _period != null;
   /**
    * Set the expression used to compute the object being indexed to the given expression.
    * @param expression the expression used to compute the object being indexed
    */
-  void set array2(Expression expression) {
+  void set array(Expression expression) {
     _target = becomeParentOf(expression);
   }
   /**
    * Set the element associated with the operator to the given element.
    * @param element the element associated with this operator
    */
-  void set element11(MethodElement element) {
-    this._element = element;
+  void set element(MethodElement element12) {
+    this._element = element12;
   }
   /**
    * Set the expression used to compute the index to the given expression.
    * @param expression the expression used to compute the index
    */
-  void set index2(Expression expression) {
+  void set index(Expression expression) {
     _index = becomeParentOf(expression);
   }
   /**
    * Set the left square bracket to the given token.
    * @param bracket the left square bracket
    */
-  void set leftBracket4(Token bracket) {
+  void set leftBracket(Token bracket) {
     _leftBracket = bracket;
   }
   /**
    * Set the period ("..") before a cascaded index expression to the given token.
    * @param period the period ("..") before a cascaded index expression
    */
-  void set period7(Token period) {
-    this._period = period;
+  void set period(Token period8) {
+    this._period = period8;
   }
   /**
    * Set the right square bracket to the given token.
    * @param bracket the right square bracket
    */
-  void set rightBracket4(Token bracket) {
+  void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_index, visitor);
   }
 }
 /**
  * Instances of the class {@code InstanceCreationExpression} represent an instance creation
  * expression.
@@ skipping 18 matching lines @@
    * The element associated with the constructor, or {@code null} if the AST structure has not been
    * resolved or if the constructor could not be resolved.
    */
   ConstructorElement _element;
   /**
    * 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) {
+  InstanceCreationExpression.full(Token keyword, ConstructorName constructorName, ArgumentList argumentList) {
     this._keyword = keyword;
     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;
   /**
    * Return the name of the constructor to be invoked.
    * @return the name of the constructor to be invoked
    */
   ConstructorName get constructorName => _constructorName;
   /**
    * Return the element associated with the constructor, or {@code null} if the AST structure has
    * not been resolved or if the constructor could not be resolved.
    * @return the element associated with the constructor
    */
   ConstructorElement get element => _element;
   Token get endToken => _argumentList.endToken;
   /**
    * Return the keyword used to indicate how an object should be created.
    * @return the keyword used to indicate how an object should be created
    */
   Token get keyword => _keyword;
   /**
    * Set the list of arguments to the constructor to the given list.
    * @param argumentList the list of arguments to the constructor
    */
-  void set argumentList6(ArgumentList argumentList) {
-    this._argumentList = becomeParentOf(argumentList);
+  void set argumentList(ArgumentList argumentList6) {
+    this._argumentList = becomeParentOf(argumentList6);
   }
   /**
    * Set the name of the constructor to be invoked to the given name.
    * @param constructorName the name of the constructor to be invoked
    */
-  void set constructorName3(ConstructorName constructorName) {
-    this._constructorName = constructorName;
+  void set constructorName(ConstructorName constructorName3) {
+    this._constructorName = constructorName3;
   }
   /**
    * Set the element associated with the constructor to the given element.
    * @param element the element associated with the constructor
    */
-  void set element12(ConstructorElement element) {
-    this._element = element;
+  void set element(ConstructorElement element13) {
+    this._element = element13;
   }
   /**
    * Set the keyword used to indicate how an object should be created to the given keyword.
    * @param keyword the keyword used to indicate how an object should be created
    */
-  void set keyword12(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword12) {
+    this._keyword = keyword12;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code IntegerLiteral} represent an integer literal expression.
  * <pre>
  * integerLiteral ::=
@@ skipping 13 matching lines @@
   Token _literal;
   /**
    * 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.con1(Token literal, int value) {
-    _jtd_constructor_58_impl(literal, value);
-  }
-  _jtd_constructor_58_impl(Token literal, int value) {
+  IntegerLiteral.full(Token literal, int value) {
     this._literal = literal;
     this._value = value;
   }
   /**
    * Initialize a newly created integer literal.
-   * @param token the token representing the literal
+   * @param literal the token representing the literal
    * @param value the value of the literal
    */
-  IntegerLiteral.con2(Token token, int value) {
-    _jtd_constructor_59_impl(token, value);
-  }
-  _jtd_constructor_59_impl(Token token, int value) {
-    _jtd_constructor_58_impl(token, value);
-  }
+  IntegerLiteral({Token literal, int value}) : this.full(literal, value);
   accept(ASTVisitor visitor) => visitor.visitIntegerLiteral(this);
   Token get beginToken => _literal;
   Token get endToken => _literal;
   /**
    * Return the token representing the literal.
    * @return the token representing the literal
    */
   Token get literal => _literal;
   /**
    * Return the value of the literal.
    * @return the value of the literal
    */
   int get value => _value;
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
-  void set literal4(Token literal) {
-    this._literal = literal;
+  void set literal(Token literal4) {
+    this._literal = literal4;
   }
   /**
    * Set the value of the literal to the given value.
    * @param value the value of the literal
    */
-  void set value6(int value) {
-    this._value = value;
+  void set value(int value6) {
+    this._value = value6;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * The abstract class {@code InterpolationElement} defines the behavior common to elements within a{@link StringInterpolation string interpolation}.
  * <pre>
  * interpolationElement ::={@link InterpolationExpression interpolationExpression}| {@link InterpolationString interpolationString}</pre>
  */
 abstract class InterpolationElement extends ASTNode {
@@ skipping 19 matching lines @@
   /**
    * The right curly bracket, or {@code null} if the expression is an identifier without brackets.
    */
   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(Token leftBracket, Expression expression, Token rightBracket) {
+  InterpolationExpression.full(Token leftBracket, Expression expression, Token rightBracket) {
     this._leftBracket = leftBracket;
     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;
   }
   /**
    * Return the expression to be evaluated for the value to be converted into a string.
    * @return the expression to be evaluated for the value to be converted into a string
    */
   Expression get expression => _expression;
   /**
    * Return the left curly bracket.
    * @return the left curly bracket
    */
   Token get leftBracket => _leftBracket;
   /**
    * Return the right curly bracket.
    * @return the right curly bracket
    */
   Token get rightBracket => _rightBracket;
   /**
    * Set the expression to be evaluated for the value to be converted into a string to the given
    * expression.
    * @param expression the expression to be evaluated for the value to be converted into a string
    */
-  void set expression6(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression6) {
+    this._expression = becomeParentOf(expression6);
   }
   /**
    * Set the left curly bracket to the given token.
    * @param leftBracket the left curly bracket
    */
-  void set leftBracket5(Token leftBracket) {
-    this._leftBracket = leftBracket;
+  void set leftBracket(Token leftBracket6) {
+    this._leftBracket = leftBracket6;
   }
   /**
    * Set the right curly bracket to the given token.
    * @param rightBracket the right curly bracket
    */
-  void set rightBracket5(Token rightBracket) {
-    this._rightBracket = rightBracket;
+  void set rightBracket(Token rightBracket6) {
+    this._rightBracket = rightBracket6;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code InterpolationString} represent a non-empty substring of an
  * interpolated string.
  * <pre>
  * interpolationString ::=
  * characters
  * </pre>
  */
 class InterpolationString extends InterpolationElement {
   /**
    * The characters that will be added to the string.
    */
   Token _contents;
   /**
    * 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(Token contents, String value) {
+  InterpolationString.full(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;
   Token get endToken => _contents;
   /**
    * Return the value of the literal.
    * @return the value of the literal
    */
   String get value => _value;
   /**
    * Set the characters that will be added to the string to those in the given string.
    * @param string the characters that will be added to the string
    */
-  void set contents2(Token string) {
+  void set contents(Token string) {
     _contents = string;
   }
   /**
    * Set the value of the literal to the given string.
    * @param string the value of the literal
    */
-  void set value7(String string) {
+  void set value(String string) {
     _value = string;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code IsExpression} represent an is expression.
  * <pre>
  * isExpression ::={@link Expression expression} 'is' '!'? {@link TypeName type}</pre>
  */
@@ skipping 14 matching lines @@
    * The name of the type being tested for.
    */
   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 {@code 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) {
+  IsExpression.full(Expression expression, Token isOperator, Token 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 {@code 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
    */
   Expression get expression => _expression;
   /**
    * Return the is operator being applied.
    * @return the is operator being applied
    */
   Token get isOperator => _isOperator;
   /**
    * Return the not operator being applied.
    * @return the not operator being applied
    */
   Token get notOperator => _notOperator;
   /**
    * Return the name of the type being tested for.
    * @return the name of the type being tested for
    */
   TypeName get type => _type;
   /**
    * Set the expression used to compute the value whose type is being tested to the given
    * expression.
    * @param expression the expression used to compute the value whose type is being tested
    */
-  void set expression7(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression7) {
+    this._expression = becomeParentOf(expression7);
   }
   /**
    * Set the is operator being applied to the given operator.
    * @param isOperator the is operator being applied
    */
-  void set isOperator2(Token isOperator) {
-    this._isOperator = isOperator;
+  void set isOperator(Token isOperator2) {
+    this._isOperator = isOperator2;
   }
   /**
    * Set the not operator being applied to the given operator.
    * @param notOperator the is operator being applied
    */
-  void set notOperator2(Token notOperator) {
-    this._notOperator = notOperator;
+  void set notOperator(Token notOperator2) {
+    this._notOperator = notOperator2;
   }
   /**
    * Set the name of the type being tested for to the given name.
    * @param name the name of the type being tested for
    */
-  void set type5(TypeName name) {
+  void set type(TypeName name) {
     this._type = becomeParentOf(name);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 /**
  * Instances of the class {@code Label} represent a label.
  * <pre>
  * label ::={@link SimpleIdentifier label} ':'
  * </pre>
  */
 class Label extends ASTNode {
   /**
    * The label being associated with the statement.
    */
   SimpleIdentifier _label;
   /**
    * The colon that separates the label from the statement.
    */
   Token _colon;
   /**
    * Initialize a newly created label.
    * @param label the label being applied
    * @param colon the colon that separates the label from whatever follows
    */
-  Label(SimpleIdentifier label, Token colon) {
+  Label.full(SimpleIdentifier label, Token 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;
   /**
    * Return the colon that separates the label from the statement.
    * @return the colon that separates the label from the statement
    */
   Token get colon => _colon;
   Token get endToken => _colon;
   /**
    * Return the label being associated with the statement.
    * @return the label being associated with the statement
    */
   SimpleIdentifier get label => _label;
   /**
    * Set the colon that separates the label from the statement to the given token.
    * @param colon the colon that separates the label from the statement
    */
-  void set colon3(Token colon) {
-    this._colon = colon;
+  void set colon(Token colon3) {
+    this._colon = colon3;
   }
   /**
    * Set the label being associated with the statement to the given label.
    * @param label the label being associated with the statement
    */
-  void set label4(SimpleIdentifier label) {
-    this._label = becomeParentOf(label);
+  void set label(SimpleIdentifier label2) {
+    this._label = becomeParentOf(label2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
  * Instances of the class {@code LabeledStatement} represent a statement that has a label associated
  * with them.
  * <pre>
  * labeledStatement ::={@link Label label}+ {@link Statement statement}</pre>
  */
 class LabeledStatement extends Statement {
   /**
    * The labels being associated with the statement.
    */
   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(List<Label> labels, Statement statement) {
+  LabeledStatement.full(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;
     }
     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 statement2(Statement statement) {
-    this._statement = becomeParentOf(statement);
+  void set statement(Statement statement2) {
+    this._statement = becomeParentOf(statement2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _labels.accept(visitor);
     safelyVisitChild(_statement, visitor);
   }
 }
 /**
  * Instances of the class {@code LibraryDirective} represent a library directive.
  * <pre>
  * libraryDirective ::={@link Annotation metadata} 'library' {@link Identifier name} ';'
@@ skipping 13 matching lines @@
    */
   Token _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) : super(comment, metadata) {
+  LibraryDirective.full(Comment comment, List<Annotation> metadata, Token libraryToken, LibraryIdentifier name, Token semicolon) : super.full(comment, metadata) {
     this._libraryToken = libraryToken;
     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 token representing the 'library' token.
    * @return the token representing the 'library' token
    */
   Token get libraryToken => _libraryToken;
   /**
    * Return the name of the library being defined.
    * @return the name of the library being defined
    */
   LibraryIdentifier get name => _name;
   /**
    * Return the semicolon terminating the directive.
    * @return the semicolon terminating the directive
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the 'library' token to the given token.
    * @param libraryToken the token representing the 'library' token
    */
-  void set libraryToken2(Token libraryToken) {
-    this._libraryToken = libraryToken;
+  void set libraryToken(Token libraryToken2) {
+    this._libraryToken = libraryToken2;
   }
   /**
    * Set the name of the library being defined to the given name.
    * @param name the name of the library being defined
    */
-  void set name9(LibraryIdentifier name) {
-    this._name = becomeParentOf(name);
+  void set name(LibraryIdentifier name6) {
+    this._name = becomeParentOf(name6);
   }
   /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
-  void set semicolon11(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon11) {
+    this._semicolon = semicolon11;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _libraryToken;
 }
 /**
  * Instances of the class {@code LibraryIdentifier} represent the identifier for a library.
  * <pre>
  * libraryIdentifier ::={@link SimpleIdentifier component} ('.' {@link SimpleIdentifier component})
  * </pre>
  */
 class LibraryIdentifier extends Identifier {
   /**
    * The components of the identifier.
    */
   NodeList<SimpleIdentifier> _components;
   /**
    * Initialize a newly created prefixed identifier.
    * @param components the components of the identifier
    */
-  LibraryIdentifier(List<SimpleIdentifier> components) {
+  LibraryIdentifier.full(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;
   /**
    * 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 {
     StringBuffer builder = new StringBuffer();
@@ skipping 34 matching lines @@
   Token _rightBracket;
   /**
    * Initialize a newly created list literal.
    * @param modifier the const modifier associated with this literal
    * @param typeArguments the type argument associated with this literal, or {@code 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 modifier, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket) : super(modifier, typeArguments) {
+  ListLiteral.full(Token modifier, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket) : super.full(modifier, typeArguments) {
     this._elements = new NodeList<Expression>(this);
     this._leftBracket = leftBracket;
     this._elements.addAll(elements);
     this._rightBracket = rightBracket;
   }
+  /**
+   * Initialize a newly created list literal.
+   * @param modifier the const modifier associated with this literal
+   * @param typeArguments the type argument associated with this literal, or {@code 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 modifier, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket}) : this.full(modifier, typeArguments, leftBracket, elements, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitListLiteral(this);
   Token get beginToken {
     Token token = modifier;
     if (token != null) {
       return token;
     }
     TypeArgumentList typeArguments6 = typeArguments;
     if (typeArguments6 != null) {
       return typeArguments6.beginToken;
     }
@@ skipping 12 matching lines @@
   Token get leftBracket => _leftBracket;
   /**
    * Return the right square bracket.
    * @return the right square bracket
    */
   Token get rightBracket => _rightBracket;
   /**
    * Set the left square bracket to the given token.
    * @param bracket the left square bracket
    */
-  void set leftBracket6(Token bracket) {
+  void set leftBracket(Token bracket) {
     _leftBracket = bracket;
   }
   /**
    * Set the right square bracket to the given token.
    * @param bracket the right square bracket
    */
-  void set rightBracket6(Token bracket) {
+  void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     _elements.accept(visitor);
   }
 }
 /**
  * The abstract class {@code Literal} defines the behavior common to nodes that represent a literal
  * expression.
@@ skipping 24 matching lines @@
   Token _rightBracket;
   /**
    * Initialize a newly created map literal.
    * @param modifier the const modifier associated with this literal
    * @param typeArguments the type argument associated with this literal, or {@code 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 modifier, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket) : super(modifier, typeArguments) {
+  MapLiteral.full(Token modifier, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket) : super.full(modifier, typeArguments) {
     this._entries = new NodeList<MapLiteralEntry>(this);
     this._leftBracket = leftBracket;
     this._entries.addAll(entries);
     this._rightBracket = rightBracket;
   }
+  /**
+   * Initialize a newly created map literal.
+   * @param modifier the const modifier associated with this literal
+   * @param typeArguments the type argument associated with this literal, or {@code 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 modifier, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket}) : this.full(modifier, typeArguments, leftBracket, entries, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitMapLiteral(this);
   Token get beginToken {
     Token token = modifier;
     if (token != null) {
       return token;
     }
     TypeArgumentList typeArguments7 = typeArguments;
     if (typeArguments7 != null) {
       return typeArguments7.beginToken;
     }
@@ skipping 12 matching lines @@
   Token get leftBracket => _leftBracket;
   /**
    * Return the right curly bracket.
    * @return the right curly bracket
    */
   Token get rightBracket => _rightBracket;
   /**
    * Set the left curly bracket to the given token.
    * @param bracket the left curly bracket
    */
-  void set leftBracket7(Token bracket) {
+  void set leftBracket(Token bracket) {
     _leftBracket = bracket;
   }
   /**
    * Set the right curly bracket to the given token.
    * @param bracket the right curly bracket
    */
-  void set rightBracket7(Token bracket) {
+  void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     _entries.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code MapLiteralEntry} represent a single key/value pair in a map
  * literal.
@@ skipping 12 matching lines @@
   /**
    * The expression computing the value that will be associated with the key.
    */
   Expression _value;
   /**
    * Initialize a newly created map literal entry.
    * @param key 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(StringLiteral key, Token separator, Expression value) {
+  MapLiteralEntry.full(StringLiteral key, Token separator, Expression value) {
     this._key = becomeParentOf(key);
     this._separator = separator;
     this._value = becomeParentOf(value);
   }
+  /**
+   * Initialize a newly created map literal entry.
+   * @param key 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({StringLiteral 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 key with which the value will be associated.
    * @return the key with which the value will be associated
    */
   StringLiteral get key => _key;
   /**
    * Return the colon that separates the key from the value.
    * @return the colon that separates the key from the value
    */
   Token get separator => _separator;
   /**
    * Return the expression computing the value that will be associated with the key.
    * @return the expression computing the value that will be associated with the key
    */
   Expression get value => _value;
   /**
    * Set the key with which the value will be associated to the given string.
    * @param string the key with which the value will be associated
    */
-  void set key2(StringLiteral string) {
+  void set key(StringLiteral string) {
     _key = becomeParentOf(string);
   }
   /**
    * Set the colon that separates the key from the value to the given token.
    * @param separator the colon that separates the key from the value
    */
-  void set separator4(Token separator) {
-    this._separator = separator;
+  void set separator(Token separator4) {
+    this._separator = separator4;
   }
   /**
    * Set the expression computing the value that will be associated with the key to the given
    * expression.
    * @param expression the expression computing the value that will be associated with the key
    */
-  void set value8(Expression expression) {
+  void set value(Expression expression) {
     _value = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_key, visitor);
     safelyVisitChild(_value, visitor);
   }
 }
 /**
  * Instances of the class {@code MethodDeclaration} represent a method declaration.
  * <pre>
@@ skipping 45 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 {@code 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, Identifier name, FormalParameterList parameters, FunctionBody body) : super(comment, metadata) {
+  MethodDeclaration.full(Comment comment, List<Annotation> metadata, Token externalKeyword, Token modifierKeyword, TypeName returnType, Token propertyKeyword, Token operatorKeyword, Identifier name, FormalParameterList parameters, FunctionBody body) : super.full(comment, metadata) {
     this._externalKeyword = externalKeyword;
     this._modifierKeyword = modifierKeyword;
     this._returnType = becomeParentOf(returnType);
     this._propertyKeyword = propertyKeyword;
     this._operatorKeyword = operatorKeyword;
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
     this._body = becomeParentOf(body);
   }
+  /**
+   * 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 {@code 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, Identifier 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;
   /**
    * Return the element associated with this method, or {@code null} if the AST structure has not
    * been resolved. The element can either be a {@link MethodElement}, if this represents the
    * declaration of a normal method, or a {@link PropertyAccessorElement} if this represents the
    * declaration of either a getter or a setter.
    * @return the element associated with this method
    */
-  ExecutableElement get element => _name != null ? _name.element as ExecutableElement : null;
+  ExecutableElement get element => _name != null ? (_name.element as ExecutableElement) : null;
   Token get endToken => _body.endToken;
   /**
    * Return the token for the 'external' keyword, or {@code null} if the constructor is not
    * external.
    * @return the token for the 'external' keyword
    */
   Token get externalKeyword => _externalKeyword;
   /**
    * Return the token representing the 'abstract' or 'static' keyword, or {@code null} if neither
    * modifier was specified.
@@ skipping 25 matching lines @@
   Token get propertyKeyword => _propertyKeyword;
   /**
    * Return the return type of the method, or {@code null} if no return type was declared.
    * @return the return type of the method
    */
   TypeName get returnType => _returnType;
   /**
    * Return {@code true} if this method declares a getter.
    * @return {@code true} if this method declares a getter
    */
-  bool isGetter() => _propertyKeyword != null && (_propertyKeyword as KeywordToken).keyword == Keyword.GET;
+  bool isGetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.GET);
   /**
    * Return {@code true} if this method declares an operator.
    * @return {@code true} if this method declares an operator
    */
   bool isOperator() => _operatorKeyword != null;
   /**
    * Return {@code true} if this method declares a setter.
    * @return {@code true} if this method declares a setter
    */
-  bool isSetter() => _propertyKeyword != null && (_propertyKeyword as KeywordToken).keyword == Keyword.SET;
+  bool isSetter() => _propertyKeyword != null && identical(((_propertyKeyword as KeywordToken)).keyword, Keyword.SET);
   /**
    * Set the body of the method to the given function body.
    * @param functionBody the body of the method
    */
-  void set body8(FunctionBody functionBody) {
+  void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
   /**
    * Set the token for the 'external' keyword to the given token.
    * @param externalKeyword the token for the 'external' keyword
    */
-  void set externalKeyword4(Token externalKeyword) {
-    this._externalKeyword = externalKeyword;
+  void set externalKeyword(Token externalKeyword4) {
+    this._externalKeyword = externalKeyword4;
   }
   /**
    * Set the token representing the 'abstract' or 'static' keyword to the given token.
    * @param modifierKeyword the token representing the 'abstract' or 'static' keyword
    */
-  void set modifierKeyword2(Token modifierKeyword) {
-    this._modifierKeyword = modifierKeyword;
+  void set modifierKeyword(Token modifierKeyword2) {
+    this._modifierKeyword = modifierKeyword2;
   }
   /**
    * Set the name of the method to the given identifier.
    * @param identifier the name of the method
    */
-  void set name10(Identifier identifier) {
+  void set name(Identifier identifier) {
     _name = becomeParentOf(identifier);
   }
   /**
    * Set the token representing the 'operator' keyword to the given token.
    * @param operatorKeyword the token representing the 'operator' keyword
    */
-  void set operatorKeyword2(Token operatorKeyword) {
-    this._operatorKeyword = operatorKeyword;
+  void set operatorKeyword(Token operatorKeyword2) {
+    this._operatorKeyword = operatorKeyword2;
   }
   /**
    * Set the parameters associated with the method to the given list of parameters.
    * @param parameters the parameters associated with the method
    */
-  void set parameters6(FormalParameterList parameters) {
-    this._parameters = becomeParentOf(parameters);
+  void set parameters(FormalParameterList parameters6) {
+    this._parameters = becomeParentOf(parameters6);
   }
   /**
    * Set the token representing the 'get' or 'set' keyword to the given token.
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    */
-  void set propertyKeyword3(Token propertyKeyword) {
-    this._propertyKeyword = propertyKeyword;
+  void set propertyKeyword(Token propertyKeyword3) {
+    this._propertyKeyword = propertyKeyword3;
   }
   /**
    * Set the return type of the method to the given type name.
    * @param typeName the return type of the method
    */
-  void set returnType6(TypeName typeName) {
+  void set returnType(TypeName typeName) {
     _returnType = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_parameters, visitor);
     safelyVisitChild(_body, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
@@ skipping 36 matching lines @@
    * The list of arguments to the method.
    */
   ArgumentList _argumentList;
   /**
    * Initialize a newly created method invocation.
    * @param target the expression producing the object on which the method is defined
    * @param period the period that separates the target from the method name
    * @param methodName the name of the method being invoked
    * @param argumentList the list of arguments to the method
    */
-  MethodInvocation(Expression target, Token period, SimpleIdentifier methodName, ArgumentList argumentList) {
+  MethodInvocation.full(Expression target, Token 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 {
     if (_target != null) {
       return _target.beginToken;
     }
@@ skipping 21 matching lines @@
    */
   Expression get realTarget {
     if (isCascaded()) {
       ASTNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
-      return (ancestor as CascadeExpression).target;
+      return ((ancestor as CascadeExpression)).target;
     }
     return _target;
   }
   /**
    * Return the expression producing the object on which the method is defined, or {@code null} if
    * there is no target (that is, the target is implicitly {@code this}) or if this method
    * invocation is part of a cascade expression.
    * @return the expression producing the object on which the method is defined
    * @see #getRealTarget()
    */
   Expression get target => _target;
   /**
    * Return {@code true} if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a{@link CascadeExpression}.
    * @return {@code true} if this expression is cascaded
    */
-  bool isCascaded() => _period != null && _period.type == TokenType.PERIOD_PERIOD;
+  bool isCascaded() => _period != null && identical(_period.type, TokenType.PERIOD_PERIOD);
   /**
    * Set the list of arguments to the method to the given list.
    * @param argumentList the list of arguments to the method
    */
-  void set argumentList7(ArgumentList argumentList) {
-    this._argumentList = becomeParentOf(argumentList);
+  void set argumentList(ArgumentList argumentList7) {
+    this._argumentList = becomeParentOf(argumentList7);
   }
   /**
    * Set the name of the method being invoked to the given identifier.
    * @param identifier the name of the method being invoked
    */
-  void set methodName2(SimpleIdentifier identifier) {
+  void set methodName(SimpleIdentifier identifier) {
     _methodName = becomeParentOf(identifier);
   }
   /**
    * Set the period that separates the target from the method name to the given token.
    * @param period the period that separates the target from the method name
    */
-  void set period8(Token period) {
-    this._period = period;
+  void set period(Token period9) {
+    this._period = period9;
   }
   /**
    * Set the expression producing the object on which the method is defined to the given expression.
    * @param expression the expression producing the object on which the method is defined
    */
-  void set target3(Expression expression) {
+  void set target(Expression expression) {
     _target = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_methodName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code NamedExpression} represent an expression that has a name associated
  * with it. They are used in method invocations when there are named parameters.
  * <pre>
  * namedExpression ::={@link Label name} {@link Expression expression}</pre>
  */
 class NamedExpression extends Expression {
   /**
    * The name associated with the expression.
    */
   Label _name;
   /**
    * 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(Label name, Expression expression) {
+  NamedExpression.full(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;
   Token get endToken => _expression.endToken;
   /**
    * Return the expression with which the name is associated.
    * @return the expression with which the name is associated
    */
   Expression get expression => _expression;
   /**
    * Return the name associated with the expression.
    * @return the name associated with the expression
    */
   Label get name => _name;
   /**
    * Set the expression with which the name is associated to the given expression.
    * @param expression the expression with which the name is associated
    */
-  void set expression8(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression8) {
+    this._expression = becomeParentOf(expression8);
   }
   /**
    * Set the name associated with the expression to the given identifier.
    * @param identifier the name associated with the expression
    */
-  void set name11(Label identifier) {
+  void set name(Label identifier) {
     _name = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * The abstract class {@code NamespaceDirective} defines the behavior common to nodes that represent
  * a directive that impacts the namespace of a library.
  * <pre>
  * directive ::={@link ExportDirective exportDirective}| {@link ImportDirective importDirective}</pre>
  */
-abstract class NamespaceDirective extends Directive {
+abstract class NamespaceDirective extends UriBasedDirective {
   /**
    * The token representing the 'import' or 'export' keyword.
    */
   Token _keyword;
   /**
-   * The URI of the library being imported or exported.
-   */
-  StringLiteral _libraryUri;
-  /**
    * The combinators used to control which names are imported or exported.
    */
   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(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon) : super(comment, metadata) {
+  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._libraryUri = becomeParentOf(libraryUri);
     this._combinators.addAll(combinators);
     this._semicolon = 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({Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon}) : this.full(comment, metadata, keyword, libraryUri, combinators, semicolon);
+  /**
    * Return the combinators used to control how names are imported or exported.
    * @return the combinators used to control how names are imported or exported
    */
   NodeList<Combinator> get combinators => _combinators;
   Token get endToken => _semicolon;
   Token get keyword => _keyword;
   /**
-   * Return the URI of the library being imported or exported.
-   * @return the URI of the library being imported or exported
-   */
-  StringLiteral get libraryUri => _libraryUri;
-  /**
    * Return the semicolon terminating the directive.
    * @return the semicolon terminating the directive
    */
   Token get semicolon => _semicolon;
   /**
    * 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 keyword13(Token exportToken) {
+  void set keyword(Token exportToken) {
     this._keyword = exportToken;
   }
   /**
-   * Set the URI of the library being imported or exported to the given literal.
-   * @param literal the URI of the library being imported or exported
-   */
-  void set libraryUri2(StringLiteral literal) {
-    _libraryUri = becomeParentOf(literal);
-  }
-  /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
-  void set semicolon12(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon12) {
+    this._semicolon = semicolon12;
   }
   Token get firstTokenAfterCommentAndMetadata => _keyword;
 }
 /**
  * The abstract class {@code NormalFormalParameter} defines the behavior common to formal parameters
  * that are required (are not optional).
  * <pre>
  * normalFormalParameter ::={@link FunctionTypedFormalParameter functionSignature}| {@link FieldFormalParameter fieldFormalParameter}| {@link SimpleFormalParameter simpleFormalParameter}</pre>
  */
 abstract class NormalFormalParameter extends FormalParameter {
   /**
    * The documentation comment associated with this parameter, or {@code null} if this parameter
    * does not have a documentation comment associated with it.
    */
   Comment _comment;
   /**
    * The annotations associated with this parameter.
    */
   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(Comment comment, List<Annotation> metadata, SimpleIdentifier identifier) {
+  NormalFormalParameter.full(Comment comment, List<Annotation> metadata, SimpleIdentifier identifier) {
     this._metadata = new NodeList<Annotation>(this);
     this._comment = becomeParentOf(comment);
     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 {@code 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 parent6 = parent;
-    if (parent6 is DefaultFormalParameter) {
-      return (parent6 as DefaultFormalParameter).kind;
+    ASTNode parent5 = parent;
+    if (parent5 is DefaultFormalParameter) {
+      return ((parent5 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;
   /**
    * Return {@code true} if this parameter is a const parameter.
    * @return {@code true} if this parameter is a const parameter
    */
   bool isConst();
   /**
    * Return {@code true} if this parameter is a final parameter.
    * @return {@code true} if this parameter is a final parameter
    */
   bool isFinal();
   /**
    * 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);
+  void set documentationComment(Comment comment3) {
+    this._comment = becomeParentOf(comment3);
   }
   /**
    * Set the name of the parameter being declared to the given identifier.
    * @param identifier the name of the parameter being declared
    */
-  void set identifier4(SimpleIdentifier identifier) {
-    this._identifier = becomeParentOf(identifier);
+  void set identifier(SimpleIdentifier identifier6) {
+    this._identifier = becomeParentOf(identifier6);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
@@ skipping 33 matching lines @@
  */
 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(Token token) {
+  NullLiteral.full(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;
   /**
    * Return the token representing the literal.
    * @return the token representing the literal
    */
   Token get literal => _literal;
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
-  void set literal5(Token literal) {
-    this._literal = literal;
+  void set literal(Token literal5) {
+    this._literal = literal5;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ParenthesizedExpression} represent a parenthesized expression.
  * <pre>
  * parenthesizedExpression ::=
  * '(' {@link Expression expression} ')'
  * </pre>
@@ skipping 10 matching lines @@
   /**
    * The right parenthesis.
    */
   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(Token leftParenthesis, Expression expression, Token rightParenthesis) {
+  ParenthesizedExpression.full(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
    */
   Expression get expression => _expression;
   /**
    * 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 expression within the parentheses to the given expression.
    * @param expression the expression within the parentheses
    */
-  void set expression9(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression9) {
+    this._expression = becomeParentOf(expression9);
   }
   /**
    * Set the left parenthesis to the given token.
    * @param parenthesis the left parenthesis
    */
-  void set leftParenthesis10(Token parenthesis) {
+  void set leftParenthesis(Token parenthesis) {
     _leftParenthesis = parenthesis;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param parenthesis the right parenthesis
    */
-  void set rightParenthesis10(Token parenthesis) {
+  void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code PartDirective} represent a part directive.
  * <pre>
  * partDirective ::={@link Annotation metadata} 'part' {@link StringLiteral partUri} ';'
  * </pre>
  */
-class PartDirective extends Directive {
+class PartDirective extends UriBasedDirective {
   /**
    * The token representing the 'part' token.
    */
   Token _partToken;
   /**
-   * The URI of the part being included.
-   */
-  StringLiteral _partUri;
-  /**
    * The semicolon terminating the directive.
    */
   Token _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) : super(comment, metadata) {
+  PartDirective.full(Comment comment, List<Annotation> metadata, Token partToken, StringLiteral partUri, Token semicolon) : super.full(comment, metadata, partUri) {
     this._partToken = partToken;
-    this._partUri = becomeParentOf(partUri);
     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);
   accept(ASTVisitor visitor) => visitor.visitPartDirective(this);
   Token get endToken => _semicolon;
   Token get keyword => _partToken;
   /**
    * Return the token representing the 'part' token.
    * @return the token representing the 'part' token
    */
   Token get partToken => _partToken;
   /**
-   * Return the URI of the part being included.
-   * @return the URI of the part being included
-   */
-  StringLiteral get partUri => _partUri;
-  /**
    * Return the semicolon terminating the directive.
    * @return the semicolon terminating the directive
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the 'part' token to the given token.
    * @param partToken the token representing the 'part' token
    */
-  void set partToken2(Token partToken) {
-    this._partToken = partToken;
-  }
-  /**
-   * Set the URI of the part being included to the given string.
-   * @param partUri the URI of the part being included
-   */
-  void set partUri2(StringLiteral partUri) {
-    this._partUri = becomeParentOf(partUri);
+  void set partToken(Token partToken2) {
+    this._partToken = partToken2;
   }
   /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
-  void set semicolon13(Token semicolon) {
-    this._semicolon = semicolon;
-  }
-  void visitChildren(ASTVisitor<Object> visitor) {
-    super.visitChildren(visitor);
-    safelyVisitChild(_partUri, visitor);
+  void set semicolon(Token semicolon13) {
+    this._semicolon = semicolon13;
   }
   Token get firstTokenAfterCommentAndMetadata => _partToken;
 }
 /**
  * Instances of the class {@code PartOfDirective} represent a part-of directive.
  * <pre>
  * partOfDirective ::={@link Annotation metadata} 'part' 'of' {@link Identifier libraryName} ';'
  * </pre>
  */
 class PartOfDirective extends Directive {
@@ skipping 15 matching lines @@
   Token _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) : super(comment, metadata) {
+  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;
     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
    */
   LibraryIdentifier get libraryName => _libraryName;
   /**
    * Return the token representing the 'of' token.
    * @return the token representing the 'of' token
    */
   Token get ofToken => _ofToken;
   /**
    * Return the token representing the 'part' token.
    * @return the token representing the 'part' token
    */
   Token get partToken => _partToken;
   /**
    * Return the semicolon terminating the directive.
    * @return the semicolon terminating the directive
    */
   Token get semicolon => _semicolon;
   /**
    * Set the name of the library that the containing compilation unit is part of to the given name.
    * @param libraryName the name of the library that the containing compilation unit is part of
    */
-  void set libraryName2(LibraryIdentifier libraryName) {
-    this._libraryName = becomeParentOf(libraryName);
+  void set libraryName(LibraryIdentifier libraryName2) {
+    this._libraryName = becomeParentOf(libraryName2);
   }
   /**
    * Set the token representing the 'of' token to the given token.
    * @param ofToken the token representing the 'of' token
    */
-  void set ofToken2(Token ofToken) {
-    this._ofToken = ofToken;
+  void set ofToken(Token ofToken2) {
+    this._ofToken = ofToken2;
   }
   /**
    * Set the token representing the 'part' token to the given token.
    * @param partToken the token representing the 'part' token
    */
-  void set partToken3(Token partToken) {
-    this._partToken = partToken;
+  void set partToken(Token partToken3) {
+    this._partToken = partToken3;
   }
   /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
-  void set semicolon14(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon14) {
+    this._semicolon = semicolon14;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_libraryName, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _partToken;
 }
 /**
  * Instances of the class {@code PostfixExpression} represent a postfix unary expression.
  * <pre>
@@ skipping 11 matching lines @@
   /**
    * The element associated with this the operator, or {@code null} if the AST structure has not
    * been resolved, if the operator is not user definable, or if the operator could not be resolved.
    */
   MethodElement _element;
   /**
    * 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) {
+  PostfixExpression.full(Expression operand, Token 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 element associated with the operator, or {@code null} if the AST structure has not
    * been resolved, if the operator is not user definable, or if the operator could not be resolved.
    * One example of the latter case is an operator that is not defined for the type of the operand.
    * @return the element associated with the operator
    */
   MethodElement get element => _element;
   Token get endToken => _operator;
   /**
    * Return the expression computing the operand for the operator.
    * @return the expression computing the operand for the operator
    */
   Expression get operand => _operand;
   /**
    * Return the postfix operator being applied to the operand.
    * @return the postfix operator being applied to the operand
    */
   Token get operator => _operator;
   /**
    * Set the element associated with the operator to the given element.
    * @param element the element associated with the operator
    */
-  void set element13(MethodElement element) {
-    this._element = element;
+  void set element(MethodElement element14) {
+    this._element = element14;
   }
   /**
    * Set the expression computing the operand for the operator to the given expression.
    * @param expression the expression computing the operand for the operator
    */
-  void set operand2(Expression expression) {
+  void set operand(Expression expression) {
     _operand = becomeParentOf(expression);
   }
   /**
    * Set the postfix operator being applied to the operand to the given operator.
    * @param operator the postfix operator being applied to the operand
    */
-  void set operator4(Token operator) {
-    this._operator = operator;
+  void set operator(Token operator4) {
+    this._operator = operator4;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
 }
 /**
  * Instances of the class {@code PrefixExpression} represent a prefix unary expression.
  * <pre>
  * prefixExpression ::={@link Token operator} {@link Expression operand}</pre>
  */
 class PrefixExpression extends Expression {
   /**
    * The prefix operator being applied to the operand.
    */
   Token _operator;
   /**
    * The expression computing the operand for the operator.
    */
   Expression _operand;
   /**
    * The element associated with the operator, or {@code null} if the AST structure has not been
    * resolved, if the operator is not user definable, or if the operator could not be resolved.
    */
   MethodElement _element;
   /**
    * 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) {
+  PrefixExpression.full(Token operator, Expression operand) {
     this._operator = operator;
     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 element associated with the operator, or {@code null} if the AST structure has not
    * been resolved, if the operator is not user definable, or if the operator could not be resolved.
    * One example of the latter case is an operator that is not defined for the type of the operand.
    * @return the element associated with the operator
    */
   MethodElement get element => _element;
   Token get endToken => _operand.endToken;
   /**
    * Return the expression computing the operand for the operator.
    * @return the expression computing the operand for the operator
    */
   Expression get operand => _operand;
   /**
    * Return the prefix operator being applied to the operand.
    * @return the prefix operator being applied to the operand
    */
   Token get operator => _operator;
   /**
    * Set the element associated with the operator to the given element.
    * @param element the element associated with the operator
    */
-  void set element14(MethodElement element) {
-    this._element = element;
+  void set element(MethodElement element15) {
+    this._element = element15;
   }
   /**
    * Set the expression computing the operand for the operator to the given expression.
    * @param expression the expression computing the operand for the operator
    */
-  void set operand3(Expression expression) {
+  void set operand(Expression expression) {
     _operand = becomeParentOf(expression);
   }
   /**
    * Set the prefix operator being applied to the operand to the given operator.
    * @param operator the prefix operator being applied to the operand
    */
-  void set operator5(Token operator) {
-    this._operator = operator;
+  void set operator(Token operator5) {
+    this._operator = operator5;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_operand, visitor);
   }
 }
 /**
  * Instances of the class {@code PrefixedIdentifier} represent either an identifier that is prefixed
  * or an access to an object property where the target of the property access is a simple
  * identifier.
  * <pre>
@@ skipping 11 matching lines @@
   /**
    * The identifier being prefixed.
    */
   SimpleIdentifier _identifier;
   /**
    * Initialize a newly created prefixed identifier.
    * @param prefix the identifier being prefixed
    * @param period the period used to separate the prefix from the identifier
    * @param identifier the prefix associated with the library in which the identifier is defined
    */
-  PrefixedIdentifier(SimpleIdentifier prefix, Token period, SimpleIdentifier identifier) {
+  PrefixedIdentifier.full(SimpleIdentifier prefix, Token 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;
   Token get endToken => _identifier.endToken;
   /**
    * Return the identifier being prefixed.
    * @return the identifier being prefixed
    */
   SimpleIdentifier get identifier => _identifier;
   String get name => "${_prefix.name}.${_identifier.name}";
   /**
    * Return the period used to separate the prefix from the identifier.
    * @return the period used to separate the prefix from the identifier
    */
   Token get period => _period;
   /**
    * Return the prefix associated with the library in which the identifier is defined.
    * @return the prefix associated with the library in which the identifier is defined
    */
   SimpleIdentifier get prefix => _prefix;
   /**
    * Set the identifier being prefixed to the given identifier.
    * @param identifier the identifier being prefixed
    */
-  void set identifier5(SimpleIdentifier identifier) {
-    this._identifier = becomeParentOf(identifier);
+  void set identifier(SimpleIdentifier identifier7) {
+    this._identifier = becomeParentOf(identifier7);
   }
   /**
    * Set the period used to separate the prefix from the identifier to the given token.
    * @param period the period used to separate the prefix from the identifier
    */
-  void set period9(Token period) {
-    this._period = period;
+  void set period(Token period10) {
+    this._period = period10;
   }
   /**
    * Set the prefix associated with the library in which the identifier is defined to the given
    * identifier.
    * @param identifier the prefix associated with the library in which the identifier is defined
    */
-  void set prefix3(SimpleIdentifier identifier) {
+  void set prefix(SimpleIdentifier identifier) {
     _prefix = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_prefix, visitor);
     safelyVisitChild(_identifier, visitor);
   }
 }
 /**
  * Instances of the class {@code PropertyAccess} represent the access of a property of an object.
  * <p>
@@ skipping 14 matching lines @@
   /**
    * The name of the property being accessed.
    */
   SimpleIdentifier _propertyName;
   /**
    * Initialize a newly created property access expression.
    * @param target the expression computing the object defining the property being accessed
    * @param operator the property access operator
    * @param propertyName the name of the property being accessed
    */
-  PropertyAccess(Expression target, Token operator, SimpleIdentifier propertyName) {
+  PropertyAccess.full(Expression target, Token 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;
   /**
    * Return the property access operator.
@@ skipping 15 matching lines @@
    */
   Expression get realTarget {
     if (isCascaded()) {
       ASTNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
-      return (ancestor as CascadeExpression).target;
+      return ((ancestor as CascadeExpression)).target;
     }
     return _target;
   }
   /**
    * Return the expression computing the object defining the property being accessed, or{@code null} if this property access is part of a cascade expression.
    * @return the expression computing the object defining the property being accessed
    * @see #getRealTarget()
    */
   Expression get target => _target;
   bool isAssignable() => true;
   /**
    * Return {@code true} if this expression is cascaded. If it is, then the target of this
    * expression is not stored locally but is stored in the nearest ancestor that is a{@link CascadeExpression}.
    * @return {@code true} if this expression is cascaded
    */
-  bool isCascaded() => _operator != null && _operator.type == TokenType.PERIOD_PERIOD;
+  bool isCascaded() => _operator != null && identical(_operator.type, TokenType.PERIOD_PERIOD);
   /**
    * Set the property access operator to the given token.
    * @param operator the property access operator
    */
-  void set operator6(Token operator) {
-    this._operator = operator;
+  void set operator(Token operator6) {
+    this._operator = operator6;
   }
   /**
    * Set the name of the property being accessed to the given identifier.
    * @param identifier the name of the property being accessed
    */
-  void set propertyName2(SimpleIdentifier identifier) {
+  void set propertyName(SimpleIdentifier identifier) {
     _propertyName = becomeParentOf(identifier);
   }
   /**
    * Set the expression computing the object defining the property being accessed to the given
    * expression.
    * @param expression the expression computing the object defining the property being accessed
    */
-  void set target4(Expression expression) {
+  void set target(Expression expression) {
     _target = becomeParentOf(expression);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_propertyName, visitor);
   }
 }
 /**
  * Instances of the class {@code RedirectingConstructorInvocation} represent the invocation of a
  * another constructor in the same class from within a constructor's initialization list.
@@ skipping 14 matching lines @@
   /**
    * The name of the constructor that is being invoked, or {@code null} if the unnamed constructor
    * is being invoked.
    */
   SimpleIdentifier _constructorName;
   /**
    * The list of arguments to the constructor.
    */
   ArgumentList _argumentList;
   /**
+   * The element associated with the constructor, or {@code null} if the AST structure has not been
+   * resolved or if the constructor could not be resolved.
+   */
+  ConstructorElement _element;
+  /**
    * 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) {
+  RedirectingConstructorInvocation.full(Token keyword, Token period, SimpleIdentifier constructorName, ArgumentList argumentList) {
     this._keyword = keyword;
     this._period = period;
     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;
   /**
    * Return the name of the constructor that is being invoked, or {@code null} if the unnamed
    * constructor is being invoked.
    * @return the name of the constructor that is being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
+  /**
+   * Return the element associated with the constructor, or {@code null} if the AST structure has
+   * not been resolved or if the constructor could not be resolved.
+   * @return the element associated with the super constructor
+   */
+  ConstructorElement get element => _element;
   Token get endToken => _argumentList.endToken;
   /**
    * Return the token for the 'this' keyword.
    * @return the token for the 'this' keyword
    */
   Token get keyword => _keyword;
   /**
    * Return the token for the period before the name of the constructor that is being invoked, or{@code null} if the unnamed constructor is being invoked.
    * @return the token for the period before the name of the constructor that is being invoked
    */
   Token get period => _period;
   /**
    * Set the list of arguments to the constructor to the given list.
    * @param argumentList the list of arguments to the constructor
    */
-  void set argumentList8(ArgumentList argumentList) {
-    this._argumentList = becomeParentOf(argumentList);
+  void set argumentList(ArgumentList argumentList8) {
+    this._argumentList = becomeParentOf(argumentList8);
   }
   /**
    * Set the name of the constructor that is being invoked to the given identifier.
    * @param identifier the name of the constructor that is being invoked
    */
-  void set constructorName4(SimpleIdentifier identifier) {
+  void set constructorName(SimpleIdentifier identifier) {
     _constructorName = becomeParentOf(identifier);
   }
   /**
+   * Set the element associated with the constructor to the given element.
+   * @param element the element associated with the constructor
+   */
+  void set element(ConstructorElement element16) {
+    this._element = element16;
+  }
+  /**
    * Set the token for the 'this' keyword to the given token.
    * @param keyword the token for the 'this' keyword
    */
-  void set keyword14(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword13) {
+    this._keyword = keyword13;
   }
   /**
    * Set the token for the period before the name of the constructor that is being invoked to the
    * given token.
    * @param period the token for the period before the name of the constructor that is being invoked
    */
-  void set period10(Token period) {
-    this._period = period;
+  void set period(Token period11) {
+    this._period = period11;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code ReturnStatement} represent a return statement.
  * <pre>
  * returnStatement ::=
@@ skipping 13 matching lines @@
   /**
    * The semicolon terminating the statement.
    */
   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(Token keyword, Expression expression, Token semicolon) {
+  ReturnStatement.full(Token keyword, Expression expression, Token semicolon) {
     this._keyword = keyword;
     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 {@code null} if no explicit value
    * was provided.
    * @return the expression computing the value to be returned
    */
   Expression get expression => _expression;
   /**
    * Return the token representing the 'return' keyword.
    * @return the token representing the 'return' keyword
    */
   Token get keyword => _keyword;
   /**
    * Return the semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * Set the expression computing the value to be returned to the given expression.
    * @param expression the expression computing the value to be returned
    */
-  void set expression10(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression10) {
+    this._expression = becomeParentOf(expression10);
   }
   /**
    * Set the token representing the 'return' keyword to the given token.
    * @param keyword the token representing the 'return' keyword
    */
-  void set keyword15(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword14) {
+    this._keyword = keyword14;
   }
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon15(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon15) {
+    this._semicolon = semicolon15;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code ScriptTag} represent the script tag that can optionally occur at
  * the beginning of a compilation unit.
  * <pre>
  * scriptTag ::=
  * '#!' (~NEWLINE)* NEWLINE
  * </pre>
  */
 class ScriptTag extends ASTNode {
   /**
    * The token representing this script tag.
    */
   Token _scriptTag;
   /**
    * Initialize a newly created script tag.
    * @param scriptTag the token representing this script tag
    */
-  ScriptTag(Token scriptTag) {
+  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);
   accept(ASTVisitor visitor) => visitor.visitScriptTag(this);
   Token get beginToken => _scriptTag;
   Token get endToken => _scriptTag;
   /**
    * Return the token representing this script tag.
    * @return the token representing this script tag
    */
   Token get scriptTag => _scriptTag;
   /**
    * Set the token representing this script tag to the given script tag.
    * @param scriptTag the token representing this script tag
    */
-  void set scriptTag3(Token scriptTag) {
-    this._scriptTag = scriptTag;
+  void set scriptTag(Token scriptTag3) {
+    this._scriptTag = scriptTag3;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ShowCombinator} represent a combinator that restricts the names
  * being imported to those in a given list.
  * <pre>
  * showCombinator ::=
  * 'show' {@link SimpleIdentifier identifier} (',' {@link SimpleIdentifier identifier})
  * </pre>
  */
 class ShowCombinator extends Combinator {
   /**
    * The list of names from the library that are made visible by this combinator.
    */
   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(Token keyword, List<SimpleIdentifier> shownNames) : super(keyword) {
+  ShowCombinator.full(Token keyword, List<SimpleIdentifier> shownNames) : super.full(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;
   /**
    * 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<Object> visitor) {
     _shownNames.accept(visitor);
   }
@@ skipping 16 matching lines @@
    */
   TypeName _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) : super(comment, metadata, identifier) {
+  SimpleFormalParameter.full(Comment comment, List<Annotation> metadata, Token keyword, TypeName type, SimpleIdentifier identifier) : super.full(comment, metadata, identifier) {
     this._keyword = keyword;
     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;
   }
   Token get endToken => identifier.endToken;
   /**
    * Return the token representing either the 'final', 'const' or 'var' keyword.
    * @return the token representing either the 'final', 'const' or 'var' keyword
    */
   Token get keyword => _keyword;
   /**
    * Return the name of the declared type of the parameter, or {@code null} if the parameter does
    * not have a declared type.
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
-  bool isConst() => (_keyword is KeywordToken) && (_keyword as KeywordToken).keyword == Keyword.CONST;
-  bool isFinal() => (_keyword is KeywordToken) && (_keyword as KeywordToken).keyword == Keyword.FINAL;
+  bool isConst() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.CONST);
+  bool isFinal() => (_keyword is KeywordToken) && identical(((_keyword as KeywordToken)).keyword, Keyword.FINAL);
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    */
-  void set keyword16(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword15) {
+    this._keyword = keyword15;
   }
   /**
    * Set the name of the declared type of the parameter to the given type name.
    * @param typeName the name of the declared type of the parameter
    */
-  void set type6(TypeName typeName) {
+  void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
   }
 }
 /**
  * Instances of the class {@code SimpleIdentifier} represent a simple identifier.
  * <pre>
  * simpleIdentifier ::=
  * initialCharacter internalCharacter
  * initialCharacter ::= '_' | '$' | letter
  * internalCharacter ::= '_' | '$' | letter | digit
  * </pre>
  */
 class SimpleIdentifier extends Identifier {
   /**
    * The token representing the identifier.
    */
   Token _token;
   /**
    * Initialize a newly created identifier.
    * @param token the token representing the identifier
    */
-  SimpleIdentifier(Token token) {
+  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);
   accept(ASTVisitor visitor) => visitor.visitSimpleIdentifier(this);
   Token get beginToken => _token;
   Token get endToken => _token;
   String get name => _token.lexeme;
   /**
    * Return the token representing the identifier.
    * @return the token representing the identifier
    */
   Token get token => _token;
   /**
    * Return {@code true} if this expression is computing a right-hand value.
    * <p>
    * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
    * @return {@code true} if this expression is in a context where a getter will be invoked
    */
   bool inGetterContext() {
-    ASTNode parent7 = parent;
+    ASTNode parent6 = parent;
     ASTNode target = this;
-    if (parent7 is PrefixedIdentifier) {
-      PrefixedIdentifier prefixed = parent7 as PrefixedIdentifier;
-      if (prefixed.identifier != this) {
-        return false;
+    if (parent6 is PrefixedIdentifier) {
+      PrefixedIdentifier prefixed = (parent6 as PrefixedIdentifier);
+      if (identical(prefixed.prefix, this)) {
+        return true;
       }
-      parent7 = prefixed.parent;
+      parent6 = prefixed.parent;
       target = prefixed;
     }
-    if (parent7 is AssignmentExpression) {
-      AssignmentExpression expr = parent7 as AssignmentExpression;
-      if (expr.leftHandSide == target && expr.operator.type == TokenType.EQ) {
+    if (parent6 is AssignmentExpression) {
+      AssignmentExpression expr = (parent6 as AssignmentExpression);
+      if (identical(expr.leftHandSide, target) && identical(expr.operator.type, TokenType.EQ)) {
         return false;
       }
     }
     return true;
   }
   /**
    * Return {@code true} if this expression is computing a left-hand value.
    * <p>
    * Note that {@link #inGetterContext()} and {@link #inSetterContext()} are not opposites, nor are
    * they mutually exclusive. In other words, it is possible for both methods to return {@code true}when invoked on the same node.
    * @return {@code true} if this expression is in a context where a setter will be invoked
    */
   bool inSetterContext() {
-    ASTNode parent8 = parent;
+    ASTNode parent7 = parent;
     ASTNode target = this;
-    if (parent8 is PrefixedIdentifier) {
-      PrefixedIdentifier prefixed = parent8 as PrefixedIdentifier;
-      if (prefixed.identifier != this) {
+    if (parent7 is PrefixedIdentifier) {
+      PrefixedIdentifier prefixed = (parent7 as PrefixedIdentifier);
+      if (identical(prefixed.prefix, this)) {
         return false;
       }
-      parent8 = prefixed.parent;
+      parent7 = prefixed.parent;
       target = prefixed;
     }
-    if (parent8 is PrefixExpression) {
-      return (parent8 as PrefixExpression).operator.type.isIncrementOperator();
-    } else if (parent8 is PostfixExpression) {
+    if (parent7 is PrefixExpression) {
+      return ((parent7 as PrefixExpression)).operator.type.isIncrementOperator();
+    } else if (parent7 is PostfixExpression) {
       return true;
-    } else if (parent8 is AssignmentExpression) {
-      return (parent8 as AssignmentExpression).leftHandSide == target;
+    } else if (parent7 is AssignmentExpression) {
+      return identical(((parent7 as AssignmentExpression)).leftHandSide, target);
     }
     return false;
   }
   bool isSynthetic() => _token.isSynthetic();
   /**
    * Set the token representing the identifier to the given token.
    * @param token the token representing the literal
    */
-  void set token12(Token token) {
-    this._token = token;
+  void set token(Token token12) {
+    this._token = token12;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code SimpleStringLiteral} represent a string literal expression that
  * does not contain any interpolations.
  * <pre>
  * simpleStringLiteral ::=
  * rawStringLiteral
@@ skipping 18 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(Token literal, String value) {
+  SimpleStringLiteral.full(Token literal, String value) {
     this._literal = literal;
     this._value = 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);
   accept(ASTVisitor visitor) => visitor.visitSimpleStringLiteral(this);
   Token get beginToken => _literal;
   Token get endToken => _literal;
   /**
    * Return the token representing the literal.
    * @return the token representing the literal
    */
   Token get literal => _literal;
   /**
    * Return the value of the literal.
    * @return the value of the literal
    */
   String get value => _value;
   /**
    * Return {@code true} if this string literal is a multi-line string.
    * @return {@code true} if this string literal is a multi-line string
    */
   bool isMultiline() {
     if (_value.length < 6) {
       return false;
     }
     return _value.endsWith("\"\"\"") || _value.endsWith("'''");
   }
   /**
    * Return {@code true} if this string literal is a raw string.
    * @return {@code true} if this string literal is a raw string
    */
-  bool isRaw() => _value.charCodeAt(0) == 0x40;
+  bool isRaw() => _value.codeUnitAt(0) == 0x40;
   bool isSynthetic() => _literal.isSynthetic();
   /**
    * Set the token representing the literal to the given token.
    * @param literal the token representing the literal
    */
-  void set literal6(Token literal) {
-    this._literal = literal;
+  void set literal(Token literal6) {
+    this._literal = literal6;
   }
   /**
    * Set the value of the literal to the given string.
    * @param string the value of the literal
    */
-  void set value9(String string) {
+  void set value(String string) {
     _value = string;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code Statement} defines the behavior common to nodes that represent a
  * statement.
  * <pre>
  * statement ::={@link Block block}| {@link VariableDeclarationStatement initializedVariableDeclaration ';'}| {@link ForStatement forStatement}| {@link ForEachStatement forEachStatement}| {@link WhileStatement whileStatement}| {@link DoStatement doStatement}| {@link SwitchStatement switchStatement}| {@link IfStatement ifStatement}| {@link TryStatement tryStatement}| {@link BreakStatement breakStatement}| {@link ContinueStatement continueStatement}| {@link ReturnStatement returnStatement}| {@link ExpressionStatement expressionStatement}| {@link FunctionDeclarationStatement functionSignature functionBody}</pre>
@@ skipping 10 matching lines @@
  */
 class StringInterpolation extends StringLiteral {
   /**
    * The elements that will be composed to produce the resulting string.
    */
   NodeList<InterpolationElement> _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) {
+  StringInterpolation.full(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;
   /**
    * 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<Object> visitor) {
     _elements.accept(visitor);
@@ skipping 25 matching lines @@
   /**
    * The name of the constructor that is being invoked, or {@code null} if the unnamed constructor
    * is being invoked.
    */
   SimpleIdentifier _constructorName;
   /**
    * The list of arguments to the constructor.
    */
   ArgumentList _argumentList;
   /**
+   * The element associated with the constructor, or {@code null} if the AST structure has not been
+   * resolved or if the constructor could not be resolved.
+   */
+  ConstructorElement _element;
+  /**
    * 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) {
+  SuperConstructorInvocation.full(Token keyword, Token period, SimpleIdentifier constructorName, ArgumentList argumentList) {
     this._keyword = keyword;
     this._period = period;
     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;
   /**
    * Return the name of the constructor that is being invoked, or {@code null} if the unnamed
    * constructor is being invoked.
    * @return the name of the constructor that is being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
+  /**
+   * Return the element associated with the constructor, or {@code null} if the AST structure has
+   * not been resolved or if the constructor could not be resolved.
+   * @return the element associated with the super constructor
+   */
+  ConstructorElement get element => _element;
   Token get endToken => _argumentList.endToken;
   /**
    * Return the token for the 'super' keyword.
    * @return the token for the 'super' keyword
    */
   Token get keyword => _keyword;
   /**
    * Return the token for the period before the name of the constructor that is being invoked, or{@code null} if the unnamed constructor is being invoked.
    * @return the token for the period before the name of the constructor that is being invoked
    */
   Token get period => _period;
   /**
    * Set the list of arguments to the constructor to the given list.
    * @param argumentList the list of arguments to the constructor
    */
-  void set argumentList9(ArgumentList argumentList) {
-    this._argumentList = becomeParentOf(argumentList);
+  void set argumentList(ArgumentList argumentList9) {
+    this._argumentList = becomeParentOf(argumentList9);
   }
   /**
    * Set the name of the constructor that is being invoked to the given identifier.
    * @param identifier the name of the constructor that is being invoked
    */
-  void set constructorName5(SimpleIdentifier identifier) {
+  void set constructorName(SimpleIdentifier identifier) {
     _constructorName = becomeParentOf(identifier);
   }
   /**
+   * Set the element associated with the constructor to the given element.
+   * @param element the element associated with the constructor
+   */
+  void set element(ConstructorElement element17) {
+    this._element = element17;
+  }
+  /**
    * Set the token for the 'super' keyword to the given token.
    * @param keyword the token for the 'super' keyword
    */
-  void set keyword17(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword16) {
+    this._keyword = keyword16;
   }
   /**
    * Set the token for the period before the name of the constructor that is being invoked to the
    * given token.
    * @param period the token for the period before the name of the constructor that is being invoked
    */
-  void set period11(Token period) {
-    this._period = period;
+  void set period(Token period12) {
+    this._period = period12;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class {@code SuperExpression} represent a super expression.
  * <pre>
  * superExpression ::=
  * 'super'
  * </pre>
  */
 class SuperExpression extends Expression {
   /**
    * The token representing the keyword.
    */
   Token _keyword;
   /**
    * Initialize a newly created super expression.
    * @param keyword the token representing the keyword
    */
-  SuperExpression(Token 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);
   accept(ASTVisitor visitor) => visitor.visitSuperExpression(this);
   Token get beginToken => _keyword;
   Token get endToken => _keyword;
   /**
    * Return the token representing the keyword.
    * @return the token representing the keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the keyword to the given token.
    * @param keyword the token representing the keyword
    */
-  void set keyword18(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword17) {
+    this._keyword = keyword17;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code SwitchCase} represent the case in a switch statement.
  * <pre>
  * switchCase ::={@link SimpleIdentifier label}* 'case' {@link Expression expression} ':' {@link Statement statement}</pre>
  */
 class SwitchCase extends SwitchMember {
   /**
    * The expression controlling whether the statements will be executed.
    */
   Expression _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) : super(labels, keyword, colon, statements) {
+  SwitchCase.full(List<Label> labels, Token keyword, Expression expression, Token colon, List<Statement> statements) : super.full(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;
   /**
    * Set the expression controlling whether the statements will be executed to the given expression.
    * @param expression the expression controlling whether the statements will be executed
    */
-  void set expression11(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression11) {
+    this._expression = becomeParentOf(expression11);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     labels.accept(visitor);
     safelyVisitChild(_expression, visitor);
     statements.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code SwitchDefault} represent the default case in a switch statement.
  * <pre>
  * switchDefault ::={@link SimpleIdentifier label}* 'default' ':' {@link Statement statement}</pre>
  */
 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(List<Label> labels, Token keyword, Token colon, List<Statement> statements) : super(labels, keyword, colon, statements) {
+  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);
   accept(ASTVisitor visitor) => visitor.visitSwitchDefault(this);
   void visitChildren(ASTVisitor<Object> visitor) {
     labels.accept(visitor);
     statements.accept(visitor);
   }
 }
 /**
  * The abstract class {@code SwitchMember} defines the behavior common to objects representing
  * elements within a switch statement.
  * <pre>
@@ skipping 19 matching lines @@
    * The statements that will be executed if this switch member is selected.
    */
   NodeList<Statement> _statements;
   /**
    * Initialize a newly created switch member.
    * @param labels the labels associated with the switch member
    * @param keyword the token representing the 'case' or 'default' keyword
    * @param colon the colon separating the keyword or the expression from the statements
    * @param statements the statements that will be executed if this switch member is selected
    */
-  SwitchMember(List<Label> labels, Token keyword, Token colon, List<Statement> statements) {
+  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);
   }
+  /**
+   * 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;
     }
     return _keyword;
   }
   /**
    * Return the colon separating the keyword or the expression from the statements.
    * @return the colon separating the keyword or the expression from the statements
    */
@@ skipping 16 matching lines @@
   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;
   /**
    * Set the colon separating the keyword or the expression from the statements to the given token.
    * @param colon the colon separating the keyword or the expression from the statements
    */
-  void set colon4(Token colon) {
-    this._colon = colon;
+  void set colon(Token colon4) {
+    this._colon = colon4;
   }
   /**
    * Set the token representing the 'case' or 'default' keyword to the given token.
    * @param keyword the token representing the 'case' or 'default' keyword
    */
-  void set keyword19(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword18) {
+    this._keyword = keyword18;
   }
 }
 /**
  * Instances of the class {@code SwitchStatement} represent a switch statement.
  * <pre>
  * switchStatement ::=
  * 'switch' '(' {@link Expression expression} ')' '{' {@link SwitchCase switchCase}* {@link SwitchDefault defaultCase}? '}'
  * </pre>
  */
 class SwitchStatement extends Statement {
@@ skipping 28 matching lines @@
   /**
    * Initialize a newly created switch statement.
    * @param keyword the token representing the 'switch' keyword
    * @param leftParenthesis the left parenthesis
    * @param expression the expression used to determine which of the switch members will be selected
    * @param rightParenthesis the right parenthesis
    * @param leftBracket the left curly bracket
    * @param members the switch members that can be selected by the expression
    * @param rightBracket the right curly bracket
    */
-  SwitchStatement(Token keyword, Token leftParenthesis, Expression expression, Token rightParenthesis, Token leftBracket, List<SwitchMember> members, Token rightBracket) {
+  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;
     this._expression = becomeParentOf(expression);
     this._rightParenthesis = rightParenthesis;
     this._leftBracket = leftBracket;
     this._members.addAll(members);
     this._rightBracket = 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({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 token representing the 'switch' keyword.
@@ skipping 23 matching lines @@
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
   /**
    * 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 expression12(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression12) {
+    this._expression = becomeParentOf(expression12);
   }
   /**
    * Set the token representing the 'switch' keyword to the given token.
    * @param keyword the token representing the 'switch' keyword
    */
-  void set keyword20(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword19) {
+    this._keyword = keyword19;
   }
   /**
    * Set the left curly bracket to the given token.
    * @param leftBracket the left curly bracket
    */
-  void set leftBracket8(Token leftBracket) {
-    this._leftBracket = leftBracket;
+  void set leftBracket(Token leftBracket7) {
+    this._leftBracket = leftBracket7;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
-  void set leftParenthesis11(Token leftParenthesis) {
-    this._leftParenthesis = leftParenthesis;
+  void set leftParenthesis(Token leftParenthesis6) {
+    this._leftParenthesis = leftParenthesis6;
   }
   /**
    * Set the right curly bracket to the given token.
    * @param rightBracket the right curly bracket
    */
-  void set rightBracket8(Token rightBracket) {
-    this._rightBracket = rightBracket;
+  void set rightBracket(Token rightBracket7) {
+    this._rightBracket = rightBracket7;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
-  void set rightParenthesis11(Token rightParenthesis) {
-    this._rightParenthesis = rightParenthesis;
+  void set rightParenthesis(Token rightParenthesis6) {
+    this._rightParenthesis = rightParenthesis6;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
     _members.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code ThisExpression} represent a this expression.
  * <pre>
  * thisExpression ::=
  * 'this'
  * </pre>
  */
 class ThisExpression extends Expression {
   /**
    * The token representing the keyword.
    */
   Token _keyword;
   /**
    * Initialize a newly created this expression.
    * @param keyword the token representing the keyword
    */
-  ThisExpression(Token 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);
   accept(ASTVisitor visitor) => visitor.visitThisExpression(this);
   Token get beginToken => _keyword;
   Token get endToken => _keyword;
   /**
    * Return the token representing the keyword.
    * @return the token representing the keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the token representing the keyword to the given token.
    * @param keyword the token representing the keyword
    */
-  void set keyword21(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword20) {
+    this._keyword = keyword20;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code ThrowExpression} represent a throw expression.
  * <pre>
  * throwExpression ::=
  * 'throw' {@link Expression expression}? ';'
  * </pre>
  */
 class ThrowExpression extends Expression {
   /**
    * The token representing the 'throw' keyword.
    */
   Token _keyword;
   /**
    * The expression computing the exception to be thrown, or {@code null} if the current exception
    * is to be re-thrown. (The latter case can only occur if the throw statement is inside a catch
    * clause.)
    */
   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(Token keyword, Expression expression) {
+  ThrowExpression.full(Token keyword, Expression expression) {
     this._keyword = keyword;
     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;
   }
   /**
    * Return the expression computing the exception to be thrown, or {@code null} if the current
    * exception is to be re-thrown. (The latter case can only occur if the throw statement is inside
    * a catch clause.)
    * @return the expression computing the exception to be thrown
    */
   Expression get expression => _expression;
   /**
    * Return the token representing the 'throw' keyword.
    * @return the token representing the 'throw' keyword
    */
   Token get keyword => _keyword;
   /**
    * Set the expression computing the exception to be thrown to the given expression.
    * @param expression the expression computing the exception to be thrown
    */
-  void set expression13(Expression expression) {
-    this._expression = becomeParentOf(expression);
+  void set expression(Expression expression13) {
+    this._expression = becomeParentOf(expression13);
   }
   /**
    * Set the token representing the 'throw' keyword to the given token.
    * @param keyword the token representing the 'throw' keyword
    */
-  void set keyword22(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword21) {
+    this._keyword = keyword21;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class {@code TopLevelVariableDeclaration} represent the declaration of one or
  * more top-level variables of the same type.
  * <pre>
  * topLevelVariableDeclaration ::=
@@ skipping 10 matching lines @@
    * The semicolon terminating the declaration.
    */
   Token _semicolon;
   /**
    * Initialize a newly created top-level variable declaration.
    * @param comment the documentation comment associated with this variable
    * @param metadata the annotations associated with this variable
    * @param variableList the top-level variables being declared
    * @param semicolon the semicolon terminating the declaration
    */
-  TopLevelVariableDeclaration(Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, Token semicolon) : super(comment, metadata) {
+  TopLevelVariableDeclaration.full(Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, Token semicolon) : super.full(comment, metadata) {
     this._variableList = becomeParentOf(variableList);
     this._semicolon = semicolon;
   }
+  /**
+   * Initialize a newly created top-level variable declaration.
+   * @param comment the documentation comment associated with this variable
+   * @param metadata the annotations associated with this variable
+   * @param variableList the top-level variables being declared
+   * @param semicolon the semicolon terminating the declaration
+   */
+  TopLevelVariableDeclaration({Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, Token semicolon}) : this.full(comment, metadata, variableList, semicolon);
   accept(ASTVisitor visitor) => visitor.visitTopLevelVariableDeclaration(this);
   Token get endToken => _semicolon;
   /**
    * Return the semicolon terminating the declaration.
    * @return the semicolon terminating the declaration
    */
   Token get semicolon => _semicolon;
   /**
    * Return the top-level variables being declared.
    * @return the top-level variables being declared
    */
   VariableDeclarationList get variables => _variableList;
   /**
    * Set the semicolon terminating the declaration to the given token.
    * @param semicolon the semicolon terminating the declaration
    */
-  void set semicolon16(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon16) {
+    this._semicolon = semicolon16;
   }
   /**
    * Set the top-level variables being declared to the given list of variables.
    * @param variableList the top-level variables being declared
    */
-  void set variables3(VariableDeclarationList variableList) {
+  void set variables(VariableDeclarationList variableList) {
     variableList = becomeParentOf(variableList);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_variableList, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
 }
 /**
  * Instances of the class {@code TryStatement} represent a try statement.
@@ skipping 27 matching lines @@
    */
   Block _finallyClause;
   /**
    * 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 finallyClause the finally clause contained in the try statement
    */
-  TryStatement(Token tryKeyword, Block body, List<CatchClause> catchClauses, Token finallyKeyword, Block finallyClause) {
+  TryStatement.full(Token tryKeyword, Block body, List<CatchClause> catchClauses, Token finallyKeyword, Block finallyClause) {
     this._catchClauses = new NodeList<CatchClause>(this);
     this._tryKeyword = tryKeyword;
     this._body = becomeParentOf(body);
     this._catchClauses.addAll(catchClauses);
     this._finallyKeyword = finallyKeyword;
     this._finallyClause = becomeParentOf(finallyClause);
   }
+  /**
+   * 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 finallyClause the finally clause contained in the try statement
+   */
+  TryStatement({Token tryKeyword, Block body, List<CatchClause> catchClauses, Token finallyKeyword, Block finallyClause}) : this.full(tryKeyword, body, catchClauses, finallyKeyword, finallyClause);
   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
@@ skipping 23 matching lines @@
   Token get finallyKeyword => _finallyKeyword;
   /**
    * Return the token representing the 'try' keyword.
    * @return the token representing the 'try' keyword
    */
   Token get tryKeyword => _tryKeyword;
   /**
    * Set the body of the statement to the given block.
    * @param block the body of the statement
    */
-  void set body9(Block block) {
+  void set body(Block block) {
     _body = becomeParentOf(block);
   }
   /**
    * Set the finally clause contained in the try statement to the given block.
    * @param block the finally clause contained in the try statement
    */
-  void set finallyClause2(Block block) {
+  void set finallyClause(Block block) {
     _finallyClause = becomeParentOf(block);
   }
   /**
    * Set the token representing the 'finally' keyword to the given token.
    * @param finallyKeyword the token representing the 'finally' keyword
    */
-  void set finallyKeyword2(Token finallyKeyword) {
-    this._finallyKeyword = finallyKeyword;
+  void set finallyKeyword(Token finallyKeyword2) {
+    this._finallyKeyword = finallyKeyword2;
   }
   /**
    * Set the token representing the 'try' keyword to the given token.
    * @param tryKeyword the token representing the 'try' keyword
    */
-  void set tryKeyword2(Token tryKeyword) {
-    this._tryKeyword = tryKeyword;
+  void set tryKeyword(Token tryKeyword2) {
+    this._tryKeyword = tryKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_body, visitor);
     _catchClauses.accept(visitor);
     safelyVisitChild(_finallyClause, visitor);
   }
 }
 /**
  * The abstract class {@code TypeAlias} defines the behavior common to declarations of type aliases.
  * <pre>
@@ skipping 13 matching lines @@
    * The semicolon terminating the declaration.
    */
   Token _semicolon;
   /**
    * Initialize a newly created type alias.
    * @param comment the documentation comment associated with this type alias
    * @param metadata the annotations associated with this type alias
    * @param keyword the token representing the 'typedef' keyword
    * @param semicolon the semicolon terminating the declaration
    */
-  TypeAlias(Comment comment, List<Annotation> metadata, Token keyword, Token semicolon) : super(comment, metadata) {
+  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);
   Token get endToken => _semicolon;
   /**
    * Return the token representing the 'typedef' keyword.
    * @return the token representing the 'typedef' keyword
    */
   Token get keyword => _keyword;
   /**
    * Return the semicolon terminating the declaration.
    * @return the semicolon terminating the declaration
    */
   Token get semicolon => _semicolon;
   /**
    * Set the token representing the 'typedef' keyword to the given token.
    * @param keyword the token representing the 'typedef' keyword
    */
-  void set keyword23(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword22) {
+    this._keyword = keyword22;
   }
   /**
    * Set the semicolon terminating the declaration to the given token.
    * @param semicolon the semicolon terminating the declaration
    */
-  void set semicolon17(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon17) {
+    this._semicolon = semicolon17;
   }
   Token get firstTokenAfterCommentAndMetadata => _keyword;
 }
 /**
  * Instances of the class {@code TypeArgumentList} represent a list of type arguments.
  * <pre>
  * typeArguments ::=
  * '<' typeName (',' typeName)* '>'
  * </pre>
  */
 class TypeArgumentList extends ASTNode {
   /**
    * The left bracket.
    */
   Token _leftBracket;
   /**
    * The type arguments associated with the type.
    */
   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(Token leftBracket, List<TypeName> arguments, Token rightBracket) {
+  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;
   }
+  /**
+   * Initialize a newly created list of type arguments.
+   * @param leftBracket the left bracket
+   * @param arguments the type arguments associated with the type
+   * @param rightBracket the right bracket
+   */
+  TypeArgumentList({Token leftBracket, List<TypeName> arguments, Token rightBracket}) : this.full(leftBracket, arguments, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitTypeArgumentList(this);
   /**
    * Return the type arguments associated with the type.
    * @return the type arguments associated with the type
    */
   NodeList<TypeName> get arguments => _arguments;
   Token get beginToken => _leftBracket;
   Token get endToken => _rightBracket;
   /**
    * Return the left bracket.
    * @return the left bracket
    */
   Token get leftBracket => _leftBracket;
   /**
    * Return the right bracket.
    * @return the right bracket
    */
   Token get rightBracket => _rightBracket;
   /**
    * Set the left bracket to the given token.
    * @param leftBracket the left bracket
    */
-  void set leftBracket9(Token leftBracket) {
-    this._leftBracket = leftBracket;
+  void set leftBracket(Token leftBracket8) {
+    this._leftBracket = leftBracket8;
   }
   /**
    * Set the right bracket to the given token.
    * @param rightBracket the right bracket
    */
-  void set rightBracket9(Token rightBracket) {
-    this._rightBracket = rightBracket;
+  void set rightBracket(Token rightBracket8) {
+    this._rightBracket = rightBracket8;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _arguments.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code TypeName} represent the name of a type, which can optionally
  * include type arguments.
  * <pre>
  * typeName ::={@link Identifier identifier} typeArguments?
@@ skipping 11 matching lines @@
   /**
    * The type being named, or {@code null} if the AST structure has not been resolved.
    */
   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 {@code null} if there are
    * no type arguments
    */
-  TypeName(Identifier name, TypeArgumentList typeArguments) {
+  TypeName.full(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 {@code 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;
   }
   /**
    * Return the name of the type.
    * @return the name of the type
    */
   Identifier get name => _name;
   /**
    * Return the type being named, or {@code null} if the AST structure has not been resolved.
    * @return the type being named
    */
   Type2 get type => _type;
   /**
    * Return the type arguments associated with the type, or {@code null} if there are no type
    * arguments.
    * @return the type arguments associated with the type
    */
   TypeArgumentList get typeArguments => _typeArguments;
   bool isSynthetic() => _name.isSynthetic() && _typeArguments == null;
   /**
    * Set the name of the type to the given identifier.
    * @param identifier the name of the type
    */
-  void set name12(Identifier identifier) {
+  void set name(Identifier identifier) {
     _name = becomeParentOf(identifier);
   }
   /**
    * Set the type being named to the given type.
    * @param type the type being named
    */
-  void set type7(Type2 type) {
-    this._type = type;
+  void set type(Type2 type3) {
+    this._type = type3;
   }
   /**
    * Set the type arguments associated with the type to the given type arguments.
    * @param typeArguments the type arguments associated with the type
    */
-  void set typeArguments2(TypeArgumentList typeArguments) {
-    this._typeArguments = becomeParentOf(typeArguments);
+  void set typeArguments(TypeArgumentList typeArguments2) {
+    this._typeArguments = becomeParentOf(typeArguments2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 /**
  * Instances of the class {@code TypeParameter} represent a type parameter.
  * <pre>
  * typeParameter ::={@link SimpleIdentifier name} ('extends' {@link TypeName bound})?
@@ skipping 15 matching lines @@
    */
   TypeName _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) : super(comment, metadata) {
+  TypeParameter.full(Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token keyword, TypeName bound) : super.full(comment, metadata) {
     this._name = becomeParentOf(name);
     this._keyword = keyword;
     this._bound = becomeParentOf(bound);
   }
+  /**
+   * Initialize a newly created type parameter.
+   * @param comment the documentation comment associated with the type parameter
+   * @param metadata the annotations associated with the type parameter
+   * @param name the name of the type parameter
+   * @param keyword the token representing the 'extends' keyword
+   * @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 {@code null} if there was no
    * explicit upper bound.
    * @return the name of the upper bound for legal arguments
    */
   TypeName get bound => _bound;
   Token get endToken {
     if (_bound == null) {
       return _name.endToken;
     }
     return _bound.endToken;
   }
   /**
    * Return the token representing the 'assert' keyword.
    * @return the token representing the 'assert' keyword
    */
   Token get keyword => _keyword;
   /**
    * Return the name of the type parameter.
    * @return the name of the type parameter
    */
   SimpleIdentifier get name => _name;
   /**
    * Set the name of the upper bound for legal arguments to the given type name.
    * @param typeName the name of the upper bound for legal arguments
    */
-  void set bound2(TypeName typeName) {
+  void set bound(TypeName typeName) {
     _bound = becomeParentOf(typeName);
   }
   /**
    * Set the token representing the 'assert' keyword to the given token.
    * @param keyword the token representing the 'assert' keyword
    */
-  void set keyword24(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword23) {
+    this._keyword = keyword23;
   }
   /**
    * Set the name of the type parameter to the given identifier.
    * @param identifier the name of the type parameter
    */
-  void set name13(SimpleIdentifier identifier) {
+  void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_bound, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 /**
@@ skipping 15 matching lines @@
   /**
    * The right angle bracket.
    */
   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(Token leftBracket, List<TypeParameter> typeParameters, Token rightBracket) {
+  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;
   }
+  /**
+   * 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 left angle bracket.
    * @return the left angle bracket
    */
   Token get leftBracket => _leftBracket;
   /**
    * Return the right angle bracket.
@@ skipping 25 matching lines @@
    * The type argument associated with this literal, or {@code null} if no type arguments were
    * declared.
    */
   TypeArgumentList _typeArguments;
   /**
    * Initialize a newly created typed literal.
    * @param modifier the const modifier associated with this literal
    * @param typeArguments the type argument associated with this literal, or {@code null} if no type
    * arguments were declared
    */
-  TypedLiteral(Token modifier, TypeArgumentList typeArguments) {
+  TypedLiteral.full(Token modifier, TypeArgumentList typeArguments) {
     this._modifier = modifier;
     this._typeArguments = becomeParentOf(typeArguments);
   }
   /**
+   * Initialize a newly created typed literal.
+   * @param modifier the const modifier associated with this literal
+   * @param typeArguments the type argument associated with this literal, or {@code null} if no type
+   * arguments were declared
+   */
+  TypedLiteral({Token modifier, TypeArgumentList typeArguments}) : this.full(modifier, typeArguments);
+  /**
    * Return the const modifier associated with this literal.
    * @return the const modifier associated with this literal
    */
   Token get modifier => _modifier;
   /**
    * Return the type argument associated with this literal, or {@code null} if no type arguments
    * were declared.
    * @return the type argument associated with this literal
    */
   TypeArgumentList get typeArguments => _typeArguments;
   /**
    * Set the modifiers associated with this literal to the given modifiers.
    * @param modifiers the modifiers associated with this literal
    */
-  void set modifier2(Token modifier) {
-    this._modifier = modifier;
+  void set modifier(Token modifier2) {
+    this._modifier = modifier2;
   }
   /**
    * Set the type argument associated with this literal to the given arguments.
    * @param typeArguments the type argument associated with this literal
    */
-  void set typeArguments3(TypeArgumentList typeArguments) {
-    this._typeArguments = typeArguments;
+  void set typeArguments(TypeArgumentList typeArguments3) {
+    this._typeArguments = typeArguments3;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 /**
+ * The abstract class {@code UriBasedDirective} defines the behavior common to nodes that represent
+ * a directive that references a URI.
+ * <pre>
+ * uriBasedDirective ::={@link ExportDirective exportDirective}| {@link ImportDirective importDirective}| {@link PartDirective partDirective}</pre>
+ */
+abstract class UriBasedDirective extends Directive {
+  /**
+   * The URI referenced by this directive.
+   */
+  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) {
+    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;
+  /**
+   * Set the URI referenced by this directive to the given URI.
+   * @param uri the URI referenced by this directive
+   */
+  void set uri(StringLiteral uri2) {
+    this._uri = becomeParentOf(uri2);
+  }
+  void visitChildren(ASTVisitor<Object> visitor) {
+    super.visitChildren(visitor);
+    safelyVisitChild(_uri, visitor);
+  }
+}
+/**
  * Instances of the class {@code VariableDeclaration} represent an identifier that has an initial
  * value associated with it. Instances of this class are always children of the class{@link VariableDeclarationList}.
  * <pre>
  * variableDeclaration ::={@link SimpleIdentifier identifier} ('=' {@link Expression initialValue})?
  * </pre>
  */
 class VariableDeclaration extends Declaration {
   /**
    * The name of the variable being declared.
    */
   SimpleIdentifier _name;
   /**
    * The equal sign separating the variable name from the initial value, or {@code null} if the
    * initial value was not specified.
    */
   Token _equals;
   /**
    * The expression used to compute the initial value for the variable, or {@code null} if the
    * initial value was not specified.
    */
   Expression _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) : super(comment, metadata) {
+  VariableDeclaration.full(Comment comment, List<Annotation> metadata, SimpleIdentifier name, Token equals, Expression initializer) : super.full(comment, metadata) {
     this._name = becomeParentOf(name);
     this._equals = equals;
     this._initializer = becomeParentOf(initializer);
   }
+  /**
+   * Initialize a newly created variable declaration.
+   * @param comment the documentation comment associated with this declaration
+   * @param metadata the annotations associated with this member
+   * @param name the name of the variable being declared
+   * @param equals the equal sign separating the variable name from the initial value
+   * @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);
   /**
    * Return the {@link VariableElement} associated with this variable, or {@code null} if the AST
    * structure has not been resolved.
    * @return the {@link VariableElement} associated with this variable
    */
-  VariableElement get element => _name != null ? _name.element as VariableElement : null;
+  VariableElement get element => _name != null ? (_name.element as VariableElement) : null;
   Token get endToken {
     if (_initializer != null) {
       return _initializer.endToken;
     }
     return _name.endToken;
   }
   /**
    * Return the equal sign separating the variable name from the initial value, or {@code null} if
    * the initial value was not specified.
    * @return the equal sign separating the variable name from the initial value
    */
   Token get equals => _equals;
   /**
    * Return the expression used to compute the initial value for the variable, or {@code null} if
    * the initial value was not specified.
    * @return the expression used to compute the initial value for the variable
    */
   Expression get initializer => _initializer;
   /**
    * Return the name of the variable being declared.
    * @return the name of the variable being declared
    */
   SimpleIdentifier get name => _name;
   /**
    * Set the equal sign separating the variable name from the initial value to the given token.
    * @param equals the equal sign separating the variable name from the initial value
    */
-  void set equals6(Token equals) {
-    this._equals = equals;
+  void set equals(Token equals6) {
+    this._equals = equals6;
   }
   /**
    * Set the expression used to compute the initial value for the variable to the given expression.
    * @param initializer the expression used to compute the initial value for the variable
    */
-  void set initializer2(Expression initializer) {
-    this._initializer = becomeParentOf(initializer);
+  void set initializer(Expression initializer2) {
+    this._initializer = becomeParentOf(initializer2);
   }
   /**
    * Set the name of the variable being declared to the given identifier.
    * @param name the name of the variable being declared
    */
-  void set name14(SimpleIdentifier name) {
-    this._name = becomeParentOf(name);
+  void set name(SimpleIdentifier name7) {
+    this._name = becomeParentOf(name7);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_initializer, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 /**
  * Instances of the class {@code VariableDeclarationList} represent the declaration of one or more
@@ skipping 20 matching lines @@
   /**
    * A list containing the individual variables being declared.
    */
   NodeList<VariableDeclaration> _variables;
   /**
    * Initialize a newly created variable 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(Token keyword, TypeName type, List<VariableDeclaration> variables) {
+  VariableDeclarationList.full(Token keyword, TypeName type, List<VariableDeclaration> variables) {
     this._variables = new NodeList<VariableDeclaration>(this);
     this._keyword = keyword;
     this._type = becomeParentOf(type);
     this._variables.addAll(variables);
   }
+  /**
+   * Initialize a newly created variable 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({Token keyword, TypeName type, List<VariableDeclaration> variables}) : this.full(keyword, type, variables);
   accept(ASTVisitor visitor) => visitor.visitVariableDeclarationList(this);
   Token get beginToken {
     if (_keyword != null) {
       return _keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return _variables.beginToken;
   }
   Token get endToken => _variables.endToken;
@@ skipping 10 matching lines @@
   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;
   /**
    * Set the token representing the 'final', 'const' or 'var' keyword to the given token.
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    */
-  void set keyword25(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword24) {
+    this._keyword = keyword24;
   }
   /**
    * Set the type of the variables being declared to the given type name.
    * @param typeName the type of the variables being declared
    */
-  void set type8(TypeName typeName) {
+  void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_type, visitor);
     _variables.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code VariableDeclarationStatement} represent a list of variables that
  * are being declared in a context where a statement is required.
  * <pre>
  * variableDeclarationStatement ::={@link VariableDeclarationList variableList} ';'
  * </pre>
  */
 class VariableDeclarationStatement extends Statement {
   /**
    * The variables being declared.
    */
   VariableDeclarationList _variableList;
   /**
    * The semicolon terminating the statement.
    */
   Token _semicolon;
   /**
    * Initialize a newly created variable declaration statement.
    * @param variableList the fields being declared
    * @param semicolon the semicolon terminating the statement
    */
-  VariableDeclarationStatement(VariableDeclarationList variableList, Token semicolon) {
+  VariableDeclarationStatement.full(VariableDeclarationList variableList, Token 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 semicolon terminating the statement.
    * @return the semicolon terminating the statement
    */
   Token get semicolon => _semicolon;
   /**
    * Return the variables being declared.
    * @return the variables being declared
    */
   VariableDeclarationList get variables => _variableList;
   /**
    * Set the semicolon terminating the statement to the given token.
    * @param semicolon the semicolon terminating the statement
    */
-  void set semicolon18(Token semicolon) {
-    this._semicolon = semicolon;
+  void set semicolon(Token semicolon18) {
+    this._semicolon = semicolon18;
   }
   /**
    * Set the variables being declared to the given list of variables.
    * @param variableList the variables being declared
    */
-  void set variables4(VariableDeclarationList variableList) {
-    this._variableList = becomeParentOf(variableList);
+  void set variables(VariableDeclarationList variableList2) {
+    this._variableList = becomeParentOf(variableList2);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_variableList, visitor);
   }
 }
 /**
  * Instances of the class {@code WhileStatement} represent a while statement.
  * <pre>
  * whileStatement ::=
  * 'while' '(' {@link Expression condition} ')' {@link Statement body}</pre>
@@ skipping 20 matching lines @@
    */
   Statement _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) {
+  WhileStatement.full(Token keyword, Token leftParenthesis, Expression condition, Token rightParenthesis, Statement body) {
     this._keyword = keyword;
     this._leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
     this._rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
+  /**
+   * 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;
   /**
    * Return the expression used to determine whether to execute the body of the loop.
    * @return the expression used to determine whether to execute the body of the loop
@@ skipping 12 matching lines @@
   Token get leftParenthesis => _leftParenthesis;
   /**
    * Return the right parenthesis.
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
   /**
    * Set the body of the loop to the given statement.
    * @param statement the body of the loop
    */
-  void set body10(Statement statement) {
+  void set body(Statement statement) {
     _body = becomeParentOf(statement);
   }
   /**
    * Set the expression used to determine whether to execute the body of the loop to the given
    * expression.
    * @param expression the expression used to determine whether to execute the body of the loop
    */
-  void set condition7(Expression expression) {
+  void set condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
   /**
    * Set the token representing the 'while' keyword to the given token.
    * @param keyword the token representing the 'while' keyword
    */
-  void set keyword26(Token keyword) {
-    this._keyword = keyword;
+  void set keyword(Token keyword25) {
+    this._keyword = keyword25;
   }
   /**
    * Set the left parenthesis to the given token.
    * @param leftParenthesis the left parenthesis
    */
-  void set leftParenthesis12(Token leftParenthesis) {
-    this._leftParenthesis = leftParenthesis;
+  void set leftParenthesis(Token leftParenthesis7) {
+    this._leftParenthesis = leftParenthesis7;
   }
   /**
    * Set the right parenthesis to the given token.
    * @param rightParenthesis the right parenthesis
    */
-  void set rightParenthesis12(Token rightParenthesis) {
-    this._rightParenthesis = rightParenthesis;
+  void set rightParenthesis(Token rightParenthesis7) {
+    this._rightParenthesis = rightParenthesis7;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class {@code WithClause} represent the with clause in a class declaration.
  * <pre>
  * withClause ::=
  * 'with' {@link TypeName mixin} (',' {@link TypeName mixin})
  * </pre>
  */
 class WithClause extends ASTNode {
   /**
    * The token representing the 'with' keyword.
    */
   Token _withKeyword;
   /**
    * The names of the mixins that were specified.
    */
   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(Token withKeyword, List<TypeName> mixinTypes) {
+  WithClause.full(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 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;
+  void set mixinKeyword(Token withKeyword2) {
+    this._withKeyword = withKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _mixinTypes.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code ConstantEvaluator} evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
  * <ul>
@@ skipping 26 matching lines @@
 class ConstantEvaluator extends GeneralizingASTVisitor<Object> {
   /**
    * The value returned for expressions (or non-expression nodes) that are not compile-time constant
    * expressions.
    */
   static Object NOT_A_CONSTANT = new Object();
   Object visitAdjacentStrings(AdjacentStrings node) {
     StringBuffer builder = new StringBuffer();
     for (StringLiteral string in node.strings) {
       Object value = string.accept(this);
-      if (value == ConstantEvaluator.NOT_A_CONSTANT) {
+      if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
       builder.add(value);
     }
     return builder.toString();
   }
   Object visitBinaryExpression(BinaryExpression node) {
-    Object leftOperand3 = node.leftOperand.accept(this);
-    if (leftOperand3 == ConstantEvaluator.NOT_A_CONSTANT) {
-      return leftOperand3;
+    Object leftOperand2 = node.leftOperand.accept(this);
+    if (identical(leftOperand2, NOT_A_CONSTANT)) {
+      return leftOperand2;
     }
-    Object rightOperand3 = node.rightOperand.accept(this);
-    if (rightOperand3 == ConstantEvaluator.NOT_A_CONSTANT) {
-      return rightOperand3;
+    Object rightOperand2 = node.rightOperand.accept(this);
+    if (identical(rightOperand2, NOT_A_CONSTANT)) {
+      return rightOperand2;
     }
     if (node.operator.type == TokenType.AMPERSAND) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) & rightOperand3 as int;
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) & (rightOperand2 as int);
       }
     } else if (node.operator.type == TokenType.AMPERSAND_AMPERSAND) {
-      if (leftOperand3 is bool && rightOperand3 is bool) {
-        return (leftOperand3 as bool) && (rightOperand3 as bool);
+      if (leftOperand2 is bool && rightOperand2 is bool) {
+        return ((leftOperand2 as bool)) && ((rightOperand2 as bool));
       }
     } else if (node.operator.type == TokenType.BANG_EQ) {
-      if (leftOperand3 is bool && rightOperand3 is bool) {
-        return (leftOperand3 as bool) != (rightOperand3 as bool);
-      } else if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) != rightOperand3;
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double) != rightOperand3;
-      } else if (leftOperand3 is String && rightOperand3 is String) {
-        return (leftOperand3 as String) != rightOperand3;
+      if (leftOperand2 is bool && rightOperand2 is bool) {
+        return ((leftOperand2 as bool)) != ((rightOperand2 as bool));
+      } else if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) != rightOperand2;
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)) != rightOperand2;
+      } else if (leftOperand2 is String && rightOperand2 is String) {
+        return ((leftOperand2 as String)) != rightOperand2;
       }
     } else if (node.operator.type == TokenType.BAR) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) | rightOperand3 as int;
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) | (rightOperand2 as int);
       }
     } else if (node.operator.type == TokenType.BAR_BAR) {
-      if (leftOperand3 is bool && rightOperand3 is bool) {
-        return (leftOperand3 as bool) || (rightOperand3 as bool);
+      if (leftOperand2 is bool && rightOperand2 is bool) {
+        return ((leftOperand2 as bool)) || ((rightOperand2 as bool));
       }
     } else if (node.operator.type == TokenType.CARET) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) ^ rightOperand3 as int;
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) ^ (rightOperand2 as int);
       }
     } else if (node.operator.type == TokenType.EQ_EQ) {
-      if (leftOperand3 is bool && rightOperand3 is bool) {
-        return (leftOperand3 as bool) == (rightOperand3 as bool);
-      } else if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) == rightOperand3;
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double) == rightOperand3;
-      } else if (leftOperand3 is String && rightOperand3 is String) {
-        return (leftOperand3 as String) == rightOperand3;
+      if (leftOperand2 is bool && rightOperand2 is bool) {
+        return identical(((leftOperand2 as bool)), ((rightOperand2 as bool)));
+      } else if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) == rightOperand2;
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)) == rightOperand2;
+      } else if (leftOperand2 is String && rightOperand2 is String) {
+        return ((leftOperand2 as String)) == rightOperand2;
       }
     } else if (node.operator.type == TokenType.GT) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int).compareTo(rightOperand3 as int) > 0;
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double).compareTo(rightOperand3 as double) > 0;
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)).compareTo((rightOperand2 as int)) > 0;
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)).compareTo((rightOperand2 as double)) > 0;
       }
     } else if (node.operator.type == TokenType.GT_EQ) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int).compareTo(rightOperand3 as int) >= 0;
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double).compareTo(rightOperand3 as double) >= 0;
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)).compareTo((rightOperand2 as int)) >= 0;
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)).compareTo((rightOperand2 as double)) >= 0;
       }
     } else if (node.operator.type == TokenType.GT_GT) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) >> (rightOperand3 as int);
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) >> ((rightOperand2 as int));
       }
     } else if (node.operator.type == TokenType.LT) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int).compareTo(rightOperand3 as int) < 0;
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double).compareTo(rightOperand3 as double) < 0;
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)).compareTo((rightOperand2 as int)) < 0;
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)).compareTo((rightOperand2 as double)) < 0;
       }
     } else if (node.operator.type == TokenType.LT_EQ) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int).compareTo(rightOperand3 as int) <= 0;
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double).compareTo(rightOperand3 as double) <= 0;
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)).compareTo((rightOperand2 as int)) <= 0;
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)).compareTo((rightOperand2 as double)) <= 0;
       }
     } else if (node.operator.type == TokenType.LT_LT) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) << (rightOperand3 as int);
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) << ((rightOperand2 as int));
       }
     } else if (node.operator.type == TokenType.MINUS) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) - rightOperand3 as int;
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double) - (rightOperand3 as double);
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) - (rightOperand2 as int);
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)) - ((rightOperand2 as double));
       }
     } else if (node.operator.type == TokenType.PERCENT) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int).remainder(rightOperand3 as int);
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double) % (rightOperand3 as double);
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)).remainder((rightOperand2 as int));
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)) % ((rightOperand2 as double));
       }
     } else if (node.operator.type == TokenType.PLUS) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) + rightOperand3 as int;
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double) + (rightOperand3 as double);
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) + (rightOperand2 as int);
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)) + ((rightOperand2 as double));
       }
     } else if (node.operator.type == TokenType.STAR) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) * rightOperand3 as int;
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double) * (rightOperand3 as double);
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) * (rightOperand2 as int);
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)) * ((rightOperand2 as double));
       }
     } else if (node.operator.type == TokenType.SLASH) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) / rightOperand3 as int;
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double) / (rightOperand3 as double);
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) ~/ (rightOperand2 as int);
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)) / ((rightOperand2 as double));
       }
     } else if (node.operator.type == TokenType.TILDE_SLASH) {
-      if (leftOperand3 is int && rightOperand3 is int) {
-        return (leftOperand3 as int) / rightOperand3 as int;
-      } else if (leftOperand3 is double && rightOperand3 is double) {
-        return (leftOperand3 as double) ~/ (rightOperand3 as double);
+      if (leftOperand2 is int && rightOperand2 is int) {
+        return ((leftOperand2 as int)) ~/ (rightOperand2 as int);
+      } else if (leftOperand2 is double && rightOperand2 is double) {
+        return ((leftOperand2 as double)) ~/ ((rightOperand2 as double));
       }
     }
     return visitExpression(node);
   }
   Object visitBooleanLiteral(BooleanLiteral node) => node.value ? true : false;
   Object visitDoubleLiteral(DoubleLiteral node) => node.value;
   Object visitIntegerLiteral(IntegerLiteral node) => node.value;
   Object visitInterpolationExpression(InterpolationExpression node) {
     Object value = node.expression.accept(this);
     if (value == null || value is bool || value is String || value is int || value is double) {
       return value;
     }
     return NOT_A_CONSTANT;
   }
   Object visitInterpolationString(InterpolationString node) => node.value;
   Object visitListLiteral(ListLiteral node) {
     List<Object> list = new List<Object>();
     for (Expression element in node.elements) {
       Object value = element.accept(this);
-      if (value == ConstantEvaluator.NOT_A_CONSTANT) {
+      if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
       list.add(value);
     }
     return list;
   }
   Object visitMapLiteral(MapLiteral node) {
     Map<String, Object> map = new Map<String, Object>();
     for (MapLiteralEntry entry in node.entries) {
-      Object key3 = entry.key.accept(this);
-      Object value10 = entry.value.accept(this);
-      if (key3 is! String || value10 == ConstantEvaluator.NOT_A_CONSTANT) {
+      Object key2 = entry.key.accept(this);
+      Object value7 = entry.value.accept(this);
+      if (key2 is! String || identical(value7, NOT_A_CONSTANT)) {
         return NOT_A_CONSTANT;
       }
-      map[key3 as String] = value10;
+      map[(key2 as String)] = value7;
     }
     return map;
   }
   Object visitMethodInvocation(MethodInvocation node) => visitNode(node);
   Object visitNode(ASTNode node) => NOT_A_CONSTANT;
   Object visitNullLiteral(NullLiteral node) => null;
   Object visitParenthesizedExpression(ParenthesizedExpression node) => node.expression.accept(this);
   Object visitPrefixedIdentifier(PrefixedIdentifier node) => getConstantValue(null);
   Object visitPrefixExpression(PrefixExpression node) {
-    Object operand4 = node.operand.accept(this);
-    if (operand4 == ConstantEvaluator.NOT_A_CONSTANT) {
-      return operand4;
+    Object operand2 = node.operand.accept(this);
+    if (identical(operand2, NOT_A_CONSTANT)) {
+      return operand2;
     }
     if (node.operator.type == TokenType.BANG) {
-      if (operand4 == true) {
+      if (identical(operand2, true)) {
         return false;
-      } else if (operand4 == false) {
+      } else if (identical(operand2, false)) {
         return true;
       }
     } else if (node.operator.type == TokenType.TILDE) {
-      if (operand4 is int) {
-        return ~(operand4 as int);
+      if (operand2 is int) {
+        return ~((operand2 as int));
       }
     } else if (node.operator.type == TokenType.MINUS) {
-      if (operand4 == null) {
+      if (operand2 == null) {
         return null;
-      } else if (operand4 is int) {
-        return -(operand4 as int);
-      } else if (operand4 is double) {
-        return -(operand4 as double);
+      } else if (operand2 is int) {
+        return -((operand2 as int));
+      } else if (operand2 is double) {
+        return -((operand2 as double));
       }
     }
     return NOT_A_CONSTANT;
   }
   Object visitPropertyAccess(PropertyAccess node) => getConstantValue(null);
   Object visitSimpleIdentifier(SimpleIdentifier node) => getConstantValue(null);
   Object visitSimpleStringLiteral(SimpleStringLiteral node) => node.value;
   Object visitStringInterpolation(StringInterpolation node) {
     StringBuffer builder = new StringBuffer();
     for (InterpolationElement element in node.elements) {
       Object value = element.accept(this);
-      if (value == ConstantEvaluator.NOT_A_CONSTANT) {
+      if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
       builder.add(value);
     }
     return builder.toString();
   }
   /**
    * Return the constant value of the static constant represented by the given element.
    * @param element the element whose value is to be returned
    * @return the constant value of the static constant
    */
   Object getConstantValue(Element element) {
     if (element is FieldElement) {
-      FieldElement field = element as FieldElement;
+      FieldElement field = (element as FieldElement);
       if (field.isStatic() && field.isConst()) {
       }
     }
     return NOT_A_CONSTANT;
   }
 }
 /**
  * Instances of the class {@code GeneralizingASTVisitor} implement an AST visitor that will
  * recursively visit all of the nodes in an AST structure (like instances of the class{@link RecursiveASTVisitor}). In addition, when a node of a specific type is visited not only
  * will the visit method for that specific type of node be invoked, but additional methods for the
@@ skipping 79 matching lines @@
   R visitLabeledStatement(LabeledStatement node) => visitStatement(node);
   R visitLibraryDirective(LibraryDirective node) => visitDirective(node);
   R visitLibraryIdentifier(LibraryIdentifier node) => visitIdentifier(node);
   R visitListLiteral(ListLiteral node) => visitTypedLiteral(node);
   R visitLiteral(Literal node) => visitExpression(node);
   R visitMapLiteral(MapLiteral node) => visitTypedLiteral(node);
   R visitMapLiteralEntry(MapLiteralEntry node) => visitNode(node);
   R visitMethodDeclaration(MethodDeclaration node) => visitClassMember(node);
   R visitMethodInvocation(MethodInvocation node) => visitNode(node);
   R visitNamedExpression(NamedExpression node) => visitExpression(node);
-  R visitNamespaceDirective(NamespaceDirective node) => visitDirective(node);
+  R visitNamespaceDirective(NamespaceDirective node) => visitUriBasedDirective(node);
   R visitNode(ASTNode node) {
     node.visitChildren(this);
     return null;
   }
   R visitNormalFormalParameter(NormalFormalParameter node) => visitFormalParameter(node);
   R visitNullLiteral(NullLiteral node) => visitLiteral(node);
   R visitParenthesizedExpression(ParenthesizedExpression node) => visitExpression(node);
-  R visitPartDirective(PartDirective node) => visitDirective(node);
+  R visitPartDirective(PartDirective node) => visitUriBasedDirective(node);
   R visitPartOfDirective(PartOfDirective node) => visitDirective(node);
   R visitPostfixExpression(PostfixExpression node) => visitExpression(node);
   R visitPrefixedIdentifier(PrefixedIdentifier node) => visitIdentifier(node);
   R visitPrefixExpression(PrefixExpression node) => visitExpression(node);
   R visitPropertyAccess(PropertyAccess node) => visitExpression(node);
   R visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) => visitConstructorInitializer(node);
   R visitReturnStatement(ReturnStatement node) => visitStatement(node);
   R visitScriptTag(ScriptTag scriptTag) => visitNode(scriptTag);
   R visitShowCombinator(ShowCombinator node) => visitCombinator(node);
   R visitSimpleFormalParameter(SimpleFormalParameter node) => visitNormalFormalParameter(node);
@@ skipping 11 matching lines @@
   R visitThisExpression(ThisExpression node) => visitExpression(node);
   R visitThrowExpression(ThrowExpression node) => visitExpression(node);
   R visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => visitCompilationUnitMember(node);
   R visitTryStatement(TryStatement node) => visitStatement(node);
   R visitTypeAlias(TypeAlias node) => visitCompilationUnitMember(node);
   R visitTypeArgumentList(TypeArgumentList node) => visitNode(node);
   R visitTypedLiteral(TypedLiteral node) => visitLiteral(node);
   R visitTypeName(TypeName node) => visitNode(node);
   R visitTypeParameter(TypeParameter node) => visitNode(node);
   R visitTypeParameterList(TypeParameterList node) => visitNode(node);
+  R visitUriBasedDirective(UriBasedDirective node) => visitDirective(node);
   R visitVariableDeclaration(VariableDeclaration node) => visitDeclaration(node);
   R visitVariableDeclarationList(VariableDeclarationList node) => visitNode(node);
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => visitStatement(node);
   R visitWhileStatement(WhileStatement node) => visitStatement(node);
   R visitWithClause(WithClause node) => visitNode(node);
 }
 /**
+ * Instances of the class {@code NodeLocator} locate the {@link ASTNode AST node} associated with a
+ * source range, given the AST structure built from the source. More specifically, they will return
+ * the {@link ASTNode AST node} with the shortest length whose source range completely encompasses
+ * the specified range.
+ */
+class NodeLocator extends GeneralizingASTVisitor<Object> {

[Jennifer Messerly, 2013/02/13 21:36:54]

nice, very useful for answering the question of "what node is at my cursor" :)

+  /**
+   * The start offset of the range used to identify the node.
+   */
+  int _startOffset = 0;
+  /**
+   * 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 {@code null} if there
+   * is no such element.
+   */
+  ASTNode _foundNode;
+  /**
+   * Initialize a newly created locator to locate one or more {@link ASTNode AST nodes} 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) {
+    _jtd_constructor_114_impl(offset);
+  }
+  _jtd_constructor_114_impl(int offset) {
+    _jtd_constructor_115_impl(offset, offset);
+  }
+  /**
+   * Initialize a newly created locator to locate one or more {@link ASTNode AST nodes} 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) {
+    _jtd_constructor_115_impl(start, end);
+  }
+  _jtd_constructor_115_impl(int start, int end) {
+    this._startOffset = start;
+    this._endOffset = end;
+  }
+  /**
+   * Return the node that was found that corresponds to the given source range, or {@code 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 {@link DartElement Dart
+   * element} in the specified source range. Return the element that was found, or {@code 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) {
+    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;
+  }
+  Object visitNode(ASTNode node) {
+    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);
+    }
+    int start = node.offset;
+    int end = start + node.length;
+    if (start <= _startOffset && _endOffset <= end) {
+      _foundNode = node;
+      throw new NodeLocator_NodeFoundException();
+    }
+    return null;
+  }
+}
+/**
  * Instances of the class {@code NodeFoundException} are used to cancel visiting after a node has
  * been found.
  */
 class NodeLocator_NodeFoundException extends RuntimeException {
   static int _serialVersionUID = 1;
 }
 /**
  * Instances of the class {@code RecursiveASTVisitor} implement an AST visitor that will recursively
  * visit all of the nodes in an AST structure. For example, using an instance of this class to visit
  * a {@link Block} will also cause all of the statements in the block to be visited.
@@ skipping 633 matching lines @@
     }
     visit(node.superclass);
     visit3(" ", node.withClause);
     visit3(" ", node.implementsClause);
     _writer.print(";");
     return null;
   }
   Object visitComment(Comment node) => null;
   Object visitCommentReference(CommentReference node) => null;
   Object visitCompilationUnit(CompilationUnit node) {
-    ScriptTag scriptTag4 = node.scriptTag;
+    ScriptTag scriptTag6 = node.scriptTag;
     NodeList<Directive> directives2 = node.directives;
-    visit(scriptTag4);
-    String prefix = scriptTag4 == null ? "" : " ";
+    visit(scriptTag6);
+    String prefix = scriptTag6 == null ? "" : " ";
     visitList4(prefix, directives2, " ");
-    prefix = scriptTag4 == null && directives2.isEmpty ? "" : " ";
+    prefix = scriptTag6 == null && directives2.isEmpty ? "" : " ";
     visitList4(prefix, node.declarations, " ");
     return null;
   }
   Object visitConditionalExpression(ConditionalExpression node) {
     visit(node.condition);
     _writer.print(" ? ");
     visit(node.thenExpression);
     _writer.print(" : ");
     visit(node.elseExpression);
     return null;
@@ skipping 52 matching lines @@
   Object visitEmptyFunctionBody(EmptyFunctionBody node) {
     _writer.print(';');
     return null;
   }
   Object visitEmptyStatement(EmptyStatement node) {
     _writer.print(';');
     return null;
   }
   Object visitExportDirective(ExportDirective node) {
     _writer.print("export ");
-    visit(node.libraryUri);
+    visit(node.uri);
     visitList4(" ", node.combinators, " ");
     _writer.print(';');
     return null;
   }
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     _writer.print("=> ");
     visit(node.expression);
     if (node.semicolon != null) {
       _writer.print(';');
     }
@@ skipping 35 matching lines @@
     String groupEnd = null;
     _writer.print('(');
     NodeList<FormalParameter> parameters9 = node.parameters;
     int size2 = parameters9.length;
     for (int i = 0; i < size2; i++) {
       FormalParameter parameter = parameters9[i];
       if (i > 0) {
         _writer.print(", ");
       }
       if (groupEnd == null && parameter is DefaultFormalParameter) {
-        if (parameter.kind == ParameterKind.NAMED) {
+        if (identical(parameter.kind, ParameterKind.NAMED)) {
           groupEnd = "}";
           _writer.print('{');
         } else {
           groupEnd = "]";
           _writer.print('[');
         }
       }
       parameter.accept(this);
     }
     if (groupEnd != null) {
@@ skipping 69 matching lines @@
     visit3(" else ", node.elseStatement);
     return null;
   }
   Object visitImplementsClause(ImplementsClause node) {
     _writer.print("implements ");
     visitList2(node.interfaces, ", ");
     return null;
   }
   Object visitImportDirective(ImportDirective node) {
     _writer.print("import ");
-    visit(node.libraryUri);
+    visit(node.uri);
     visit3(" as ", node.prefix);
     visitList4(" ", node.combinators, " ");
     _writer.print(';');
     return null;
   }
   Object visitIndexExpression(IndexExpression node) {
     if (node.isCascaded()) {
       _writer.print("..");
     } else {
       visit(node.array);
@@ skipping 119 matching lines @@
     return null;
   }
   Object visitParenthesizedExpression(ParenthesizedExpression node) {
     _writer.print('(');
     visit(node.expression);
     _writer.print(')');
     return null;
   }
   Object visitPartDirective(PartDirective node) {
     _writer.print("part ");
-    visit(node.partUri);
+    visit(node.uri);
     _writer.print(';');
     return null;
   }
   Object visitPartOfDirective(PartOfDirective node) {
     _writer.print("part of ");
     visit(node.libraryName);
     _writer.print(';');
     return null;
   }
   Object visitPostfixExpression(PostfixExpression node) {
@@ skipping 344 matching lines @@
     return elements[elements.length - 1].endToken;
   }
   /**
    * Return the node that is the parent of each of the elements in the list.
    * @return the node that is the parent of each of the elements in the list
    */
   ASTNode getOwner() {
     return owner;
   }
 }