New Analysis Engine snapshot.

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 'source.dart' show LineInfo;
@@ skipping 257 matching lines @@
   R visitLabel(Label node);
   R visitLabeledStatement(LabeledStatement node);
   R visitLibraryDirective(LibraryDirective node);
   R visitLibraryIdentifier(LibraryIdentifier node);
   R visitListLiteral(ListLiteral node);
   R visitMapLiteral(MapLiteral node);
   R visitMapLiteralEntry(MapLiteralEntry node);
   R visitMethodDeclaration(MethodDeclaration node);
   R visitMethodInvocation(MethodInvocation node);
   R visitNamedExpression(NamedExpression node);
+  R visitNativeFunctionBody(NativeFunctionBody node);
   R visitNullLiteral(NullLiteral node);
   R visitParenthesizedExpression(ParenthesizedExpression node);
   R visitPartDirective(PartDirective node);
   R visitPartOfDirective(PartOfDirective node);
   R visitPostfixExpression(PostfixExpression node);
   R visitPrefixedIdentifier(PrefixedIdentifier node);
   R visitPrefixExpression(PrefixExpression node);
   R visitPropertyAccess(PropertyAccess node);
   R visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node);
   R visitRethrowExpression(RethrowExpression node);
@@ skipping 179 matching lines @@
     return children;
   }
 }
 /**
  * Instances of the class {@code Annotation} represent an annotation that can be associated with an
  * AST node.
  * <pre>
  * metadata ::=
  * annotation
  * annotation ::=
- * '@' {@link Identifier qualified} (‘.’ {@link SimpleIdentifier identifier})? {@link ArgumentList arguments}?
+ * '@' {@link Identifier qualified} ('.' {@link SimpleIdentifier identifier})? {@link ArgumentList arguments}?
  * </pre>
  * @coverage dart.engine.ast
  */
 class Annotation extends ASTNode {
   /**
    * The at sign that introduced the annotation.
    */
   Token _atSign;
   /**
    * The name of the class defining the constructor that is being invoked or the name of the field
@@ skipping 105 matching lines @@
    * @param constructorName the name of the constructor being invoked
    */
   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 name(Identifier name2) {
-    this._name = becomeParentOf(name2);
+  void set name(Identifier name3) {
+    this._name = becomeParentOf(name3);
   }
   /**
    * Set the period before the constructor name to the given token.
    * @param period the period before the constructor name
    */
   void set period(Token period2) {
     this._period = period2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_name, visitor);
@@ skipping 42 matching lines @@
   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 identifier(SimpleIdentifier identifier7) {
-    this._identifier = becomeParentOf(identifier7);
+  void set identifier(SimpleIdentifier identifier8) {
+    this._identifier = becomeParentOf(identifier8);
   }
   /**
    * Set the token representing the question mark to the given token.
    * @param question the token representing the question mark
    */
   void set question(Token question2) {
     this._question = question2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_identifier, visitor);
@@ skipping 1449 matching lines @@
    * Set the implements clause for this class to the given implements clause.
    * @param implementsClause the implements clause for this class
    */
   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 name(SimpleIdentifier name3) {
-    this._name = becomeParentOf(name3);
+  void set name(SimpleIdentifier name4) {
+    this._name = becomeParentOf(name4);
   }
   /**
    * 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 superclass(TypeName superclass2) {
     this._superclass = becomeParentOf(superclass2);
   }
   /**
    * Set the type parameters for the class to the given list of parameters.
@@ skipping 137 matching lines @@
   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 the tokens representing the comment.
+   * @return the tokens representing the comment
+   */
+  List<Token> get tokens => _tokens;
+  /**
    * Return {@code true} if this is a block comment.
    * @return {@code true} if this is a block comment
    */
   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() => 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() => 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 {
+class CommentType implements Comparable<CommentType> {
   /**
    * An end-of-line comment.
    */
   static final CommentType END_OF_LINE = new CommentType('END_OF_LINE', 0);
   /**
    * A block comment.
    */
   static final CommentType BLOCK = new CommentType('BLOCK', 1);
   /**
    * A documentation comment.
    */
   static final CommentType DOCUMENTATION = new CommentType('DOCUMENTATION', 2);
   static final List<CommentType> values = [END_OF_LINE, BLOCK, DOCUMENTATION];
   final String __name;
   final int __ordinal;
   int get ordinal => __ordinal;
   CommentType(this.__name, this.__ordinal) {
   }
+  int compareTo(CommentType other) => __ordinal - other.__ordinal;
   String toString() => __name;
 }
 /**
  * Instances of the class {@code CommentReference} represent a reference to a Dart element that is
  * found within a documentation comment.
  * <pre>
  * commentReference ::=
  * '[' 'new'? {@link Identifier identifier} ']'
  * </pre>
  * @coverage dart.engine.ast
@@ skipping 32 matching lines @@
   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 identifier(Identifier identifier24) {
-    identifier24 = becomeParentOf(identifier24);
+  void set identifier(Identifier identifier26) {
+    identifier26 = becomeParentOf(identifier26);
   }
   /**
    * Set the token representing the 'new' keyword to the given token.
    * @param newKeyword the token representing the 'new' keyword
    */
   void set newKeyword(Token newKeyword2) {
     this._newKeyword = newKeyword2;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     safelyVisitChild(_identifier, visitor);
@@ skipping 157 matching lines @@
   }
   /**
    * 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}
+   * @param errors an array of parsing errors, if {@code null} 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}
+   * @param errors an array of resolution errors, if {@code null} 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 scriptTag(ScriptTag scriptTag2) {
     this._scriptTag = becomeParentOf(scriptTag2);
@@ skipping 706 matching lines @@
    * Set the element associated with this constructor name to the given element.
    * @param element the element associated with this constructor name
    */
   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 name(SimpleIdentifier name4) {
-    this._name = becomeParentOf(name4);
+  void set name(SimpleIdentifier name5) {
+    this._name = becomeParentOf(name5);
   }
   /**
    * 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 period(Token period5) {
     this._period = period5;
   }
   /**
    * Set the name of the type defining the constructor to the given type name.
@@ skipping 155 matching lines @@
    * Initialize a newly created formal parameter.
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    * @param type the name of the declared type of the parameter
    * @param identifier the name of the parameter being declared
    */
   DeclaredIdentifier({Comment comment, List<Annotation> metadata, Token keyword, TypeName type, SimpleIdentifier identifier}) : this.full(comment, metadata, keyword, type, identifier);
   accept(ASTVisitor visitor) => visitor.visitDeclaredIdentifier(this);
   LocalVariableElement get element {
-    SimpleIdentifier identifier11 = identifier;
-    if (identifier11 == null) {
+    SimpleIdentifier identifier12 = identifier;
+    if (identifier12 == null) {
       return null;
     }
-    return identifier11.element as LocalVariableElement;
+    return identifier12.element as LocalVariableElement;
   }
   Token get endToken => _identifier.endToken;
   /**
    * Return the name of the variable being declared.
    * @return the name of the variable being declared
    */
   SimpleIdentifier get identifier => _identifier;
   /**
    * Return the token representing either the 'final', 'const' or 'var' keyword.
    * @return the token representing either the 'final', 'const' or 'var' keyword
@@ skipping 1457 matching lines @@
  * formalParameter ::={@link NormalFormalParameter normalFormalParameter}| {@link DefaultFormalParameter namedFormalParameter}| {@link DefaultFormalParameter optionalFormalParameter}</pre>
  * @coverage dart.engine.ast
  */
 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 identifier12 = identifier;
-    if (identifier12 == null) {
+    SimpleIdentifier identifier13 = identifier;
+    if (identifier13 == null) {
       return null;
     }
-    return identifier12.element as ParameterElement;
+    return identifier13.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 597 matching lines @@
   /**
    * 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 name(SimpleIdentifier name5) {
-    this._name = becomeParentOf(name5);
+  void set name(SimpleIdentifier name6) {
+    this._name = becomeParentOf(name6);
   }
   /**
    * 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 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.
@@ skipping 1332 matching lines @@
    * Set the token representing the 'library' token to the given token.
    * @param libraryToken the token representing the 'library' token
    */
   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 name(LibraryIdentifier name6) {
-    this._name = becomeParentOf(name6);
+  void set name(LibraryIdentifier name7) {
+    this._name = becomeParentOf(name7);
   }
   /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
   void set semicolon(Token semicolon11) {
     this._semicolon = semicolon11;
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     super.visitChildren(visitor);
@@ skipping 855 matching lines @@
   /**
    * Set the semicolon terminating the directive to the given token.
    * @param semicolon the semicolon terminating the directive
    */
   void set semicolon(Token semicolon12) {
     this._semicolon = semicolon12;
   }
   Token get firstTokenAfterCommentAndMetadata => _keyword;
 }
 /**
+ * Instances of the class {@code NativeFunctionBody} represent a function body that consists of a
+ * native keyword followed by a string literal.
+ * <pre>
+ * nativeFunctionBody ::=
+ * 'native' {@link SimpleStringLiteral simpleStringLiteral} ';'
+ * </pre>
+ * @coverage dart.engine.ast
+ */
+class NativeFunctionBody extends FunctionBody {
+  /**
+   * The token representing 'native' that marks the start of the function body.
+   */
+  Token _nativeToken;
+  /**
+   * The string literal, after the 'native' token.
+   */
+  StringLiteral _stringLiteral;
+  /**
+   * The token representing the semicolon that marks the end of the function body.
+   */
+  Token _semicolon;
+  /**
+   * Initialize a newly created function body consisting of the 'native' token, a string literal,
+   * and a semicolon.
+   * @param nativeToken the token representing 'native' that marks the start of the function body
+   * @param stringLiteral the string literal
+   * @param semicolon the token representing the semicolon that marks the end of the function body
+   */
+  NativeFunctionBody.full(Token nativeToken, StringLiteral stringLiteral, Token semicolon) {
+    this._nativeToken = nativeToken;
+    this._stringLiteral = becomeParentOf(stringLiteral);
+    this._semicolon = semicolon;
+  }
+  /**
+   * Initialize a newly created function body consisting of the 'native' token, a string literal,
+   * and a semicolon.
+   * @param nativeToken the token representing 'native' that marks the start of the function body
+   * @param stringLiteral the string literal
+   * @param semicolon the token representing the semicolon that marks the end of the function body
+   */
+  NativeFunctionBody({Token nativeToken, StringLiteral stringLiteral, Token semicolon}) : this.full(nativeToken, stringLiteral, semicolon);
+  accept(ASTVisitor visitor) => visitor.visitNativeFunctionBody(this);
+  Token get beginToken => _nativeToken;
+  Token get endToken => _semicolon;
+  /**
+   * Return the simple identifier representing the 'native' token.
+   * @return the simple identifier representing the 'native' token
+   */
+  Token get nativeToken => _nativeToken;
+  /**
+   * 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;
+  /**
+   * Return the string literal representing the string after the 'native' token.
+   * @return the string literal representing the string after the 'native' token
+   */
+  StringLiteral get stringLiteral => _stringLiteral;
+  void visitChildren(ASTVisitor<Object> visitor) {
+    safelyVisitChild(_stringLiteral, visitor);
+  }
+}
+/**
  * 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>
  * @coverage dart.engine.ast
  */
 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.
@@ skipping 61 matching lines @@
    * 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 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 identifier(SimpleIdentifier identifier8) {
-    this._identifier = becomeParentOf(identifier8);
+  void set identifier(SimpleIdentifier identifier9) {
+    this._identifier = becomeParentOf(identifier9);
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
@@ skipping 542 matching lines @@
   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 identifier(SimpleIdentifier identifier9) {
-    this._identifier = becomeParentOf(identifier9);
+  void set identifier(SimpleIdentifier identifier10) {
+    this._identifier = becomeParentOf(identifier10);
   }
   /**
    * 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 period(Token period10) {
     this._period = period10;
   }
   /**
    * Set the prefix associated with the library in which the identifier is defined to the given
@@ skipping 604 matching lines @@
     } else if (parent7 is ConstructorDeclaration) {
       return identical(this, ((parent7 as ConstructorDeclaration)).name);
     } else if (parent7 is FunctionDeclaration) {
       return identical(this, ((parent7 as FunctionDeclaration)).name);
     } else if (parent7 is FunctionTypeAlias) {
       return identical(this, ((parent7 as FunctionTypeAlias)).name);
     } else if (parent7 is Label) {
       return identical(this, ((parent7 as Label)).label) && (parent7.parent is LabeledStatement);
     } else if (parent7 is MethodDeclaration) {
       return identical(this, ((parent7 as MethodDeclaration)).name);
-    } else if (parent7 is NormalFormalParameter) {
+    } else if (parent7 is FunctionTypedFormalParameter || parent7 is SimpleFormalParameter) {
       return identical(this, ((parent7 as NormalFormalParameter)).identifier);
     } else if (parent7 is TypeParameter) {
       return identical(this, ((parent7 as TypeParameter)).name);
     } else if (parent7 is VariableDeclaration) {
       return identical(this, ((parent7 as VariableDeclaration)).name);
     }
     return false;
   }
   /**
    * Return {@code true} if this expression is computing a right-hand value.
@@ skipping 13 matching lines @@
       parent8 = prefixed.parent;
       target = prefixed;
     } else if (parent8 is PropertyAccess) {
       PropertyAccess access = parent8 as PropertyAccess;
       if (identical(access.target, this)) {
         return true;
       }
       parent8 = access.parent;
       target = access;
     }
+    if (parent8 is Label) {
+      return false;
+    }
     if (parent8 is AssignmentExpression) {
       AssignmentExpression expr = parent8 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.
@@ skipping 34 matching lines @@
    * Set the element associated with this identifier to the given element.
    * @param element the element associated with this identifier
    */
   void set element(Element element16) {
     this._element = element16;
   }
   /**
    * Set the token representing the identifier to the given token.
    * @param token the token representing the literal
    */
-  void set token(Token token12) {
-    this._token = token12;
+  void set token(Token token17) {
+    this._token = token17;
   }
   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 21 matching lines @@
    * The value of the literal.
    */
   String _value;
   /**
    * Initialize a newly created simple string literal.
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   SimpleStringLiteral.full(Token literal, String value) {
     this._literal = literal;
-    this._value = value;
+    this._value = StringUtilities.intern(value);
   }
   /**
    * Initialize a newly created simple string literal.
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   SimpleStringLiteral({Token literal, String value}) : this.full(literal, value);
   accept(ASTVisitor visitor) => visitor.visitSimpleStringLiteral(this);
   Token get beginToken => _literal;
   Token get endToken => _literal;
@@ skipping 28 matching lines @@
    * @param literal the token representing the 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 value(String string) {
-    _value = string;
+    _value = StringUtilities.intern(_value);
   }
   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>
  * @coverage dart.engine.ast
@@ skipping 1454 matching lines @@
    * 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 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 name(SimpleIdentifier name7) {
-    this._name = becomeParentOf(name7);
+  void set name(SimpleIdentifier name8) {
+    this._name = becomeParentOf(name8);
   }
   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 375 matching lines @@
  * those values.
  * @coverage dart.engine.ast
  */
 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();
   /**
-   * The error reporter by which errors will be reported.
+   * Initialize a newly created constant evaluator.
    */
-  ErrorReporter _errorReporter;
-  /**
-   * Initialize a newly created constant evaluator.
-   * @param errorReporter the error reporter by which errors will be reported
-   */
-  ConstantEvaluator(ErrorReporter errorReporter) {
-    this._errorReporter = errorReporter;
+  ConstantEvaluator() {
   }
   Object visitAdjacentStrings(AdjacentStrings node) {
     JavaStringBuilder builder = new JavaStringBuilder();
     for (StringLiteral string in node.strings) {
       Object value = string.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
       builder.append(value);
     }
@@ skipping 103 matching lines @@
         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 (leftOperand2 is int && rightOperand2 is int) {
           if (rightOperand2 != 0) {
             return ((leftOperand2 as int)) ~/ (rightOperand2 as int);
           } else {
-            reportDivideByZeroError(node);
-            return 0;
+            return ((leftOperand2 as int)).toDouble() / ((rightOperand2 as int)).toDouble();
           }
         } else if (leftOperand2 is double && rightOperand2 is double) {
-          if (rightOperand2 != 0) {
-            return ((leftOperand2 as double)) / ((rightOperand2 as double));
-          } else {
-            reportDivideByZeroError(node);
-            return 0;
-          }
+          return ((leftOperand2 as double)) / ((rightOperand2 as double));
         }
       } else if (node.operator.type == TokenType.TILDE_SLASH) {
         if (leftOperand2 is int && rightOperand2 is int) {
           if (rightOperand2 != 0) {
             return ((leftOperand2 as int)) ~/ (rightOperand2 as int);
           } else {
-            reportDivideByZeroError(node);
             return 0;
           }
         } else if (leftOperand2 is double && rightOperand2 is double) {
-          if (rightOperand2 != 0) {
-            return ((leftOperand2 as double)) ~/ ((rightOperand2 as double));
-          } else {
-            reportDivideByZeroError(node);
-            return 0;
-          }
+          return ((leftOperand2 as double)) ~/ ((rightOperand2 as double));
         }
       }
       break;
     }
     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) {
@@ skipping 81 matching lines @@
    * @return the constant value of the static constant
    */
   Object getConstantValue(Element element) {
     if (element is FieldElement) {
       FieldElement field = element as FieldElement;
       if (field.isStatic() && field.isConst()) {
       }
     }
     return NOT_A_CONSTANT;
   }
-  void reportDivideByZeroError(BinaryExpression node) {
-    _errorReporter.reportError(CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION_DIVIDE_BY_ZERO, node, []);
-  }
 }
 /**
  * Instances of the class {@code ElementLocator} locate the {@link Element Dart model element}associated with a given {@link ASTNode AST node}.
  * @coverage dart.engine.ast
  */
 class ElementLocator {
   /**
    * Locate the {@link Element Dart model element} associated with the given {@link ASTNode AST
    * node}.
    * @param node the node (not {@code null})
    * @return the associated element, or {@code null} if none is found
    */
   static Element locate(ASTNode node) {
     ElementLocator_ElementMapper mapper = new ElementLocator_ElementMapper();
     return node.accept(mapper);
   }
   /**
    * Clients should use {@link #locate(ASTNode)}.
    */
   ElementLocator() {
   }
 }
 /**
  * Visitor that maps nodes to elements.
  */
 class ElementLocator_ElementMapper extends GeneralizingASTVisitor<Element> {
   Element visitBinaryExpression(BinaryExpression node) => node.element;
   Element visitClassDeclaration(ClassDeclaration node) => node.element;
+  Element visitCompilationUnit(CompilationUnit node) => node.element;
+  Element visitConstructorDeclaration(ConstructorDeclaration node) => node.element;
   Element visitFunctionDeclaration(FunctionDeclaration node) => node.element;
   Element visitIdentifier(Identifier node) => node.element;
   Element visitImportDirective(ImportDirective node) => node.element;
   Element visitIndexExpression(IndexExpression node) => node.element;
+  Element visitInstanceCreationExpression(InstanceCreationExpression node) => node.element;
   Element visitLibraryDirective(LibraryDirective node) => node.element;
   Element visitMethodDeclaration(MethodDeclaration node) => node.element;
+  Element visitMethodInvocation(MethodInvocation node) => node.methodName.element;
   Element visitPostfixExpression(PostfixExpression node) => node.element;
   Element visitPrefixedIdentifier(PrefixedIdentifier node) => node.element;
   Element visitPrefixExpression(PrefixExpression node) => node.element;
   Element visitStringLiteral(StringLiteral node) {
     ASTNode parent12 = node.parent;
     if (parent12 is UriBasedDirective) {
       return ((parent12 as UriBasedDirective)).element;
     }
     return null;
   }
@@ skipping 88 matching lines @@
   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) => visitExpression(node);
   R visitNamedExpression(NamedExpression node) => visitExpression(node);
   R visitNamespaceDirective(NamespaceDirective node) => visitUriBasedDirective(node);
+  R visitNativeFunctionBody(NativeFunctionBody node) => visitFunctionBody(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) => visitUriBasedDirective(node);
   R visitPartOfDirective(PartOfDirective node) => visitDirective(node);
   R visitPostfixExpression(PostfixExpression node) => visitExpression(node);
@@ skipping 54 matching lines @@
    * 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_119_impl(offset);
+    _jtd_constructor_120_impl(offset);
   }
-  _jtd_constructor_119_impl(int offset) {
-    _jtd_constructor_120_impl(offset, offset);
+  _jtd_constructor_120_impl(int offset) {
+    _jtd_constructor_121_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_120_impl(start, end);
+    _jtd_constructor_121_impl(start, end);
   }
-  _jtd_constructor_120_impl(int start, int end) {
+  _jtd_constructor_121_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;
   /**
@@ skipping 301 matching lines @@
     return null;
   }
   R visitMethodInvocation(MethodInvocation node) {
     node.visitChildren(this);
     return null;
   }
   R visitNamedExpression(NamedExpression node) {
     node.visitChildren(this);
     return null;
   }
+  R visitNativeFunctionBody(NativeFunctionBody node) {
+    node.visitChildren(this);
+    return null;
+  }
   R visitNullLiteral(NullLiteral node) {
     node.visitChildren(this);
     return null;
   }
   R visitParenthesizedExpression(ParenthesizedExpression node) {
     node.visitChildren(this);
     return null;
   }
   R visitPartDirective(PartDirective node) {
     node.visitChildren(this);
@@ skipping 194 matching lines @@
   R visitLabel(Label node) => null;
   R visitLabeledStatement(LabeledStatement node) => null;
   R visitLibraryDirective(LibraryDirective node) => null;
   R visitLibraryIdentifier(LibraryIdentifier node) => null;
   R visitListLiteral(ListLiteral node) => null;
   R visitMapLiteral(MapLiteral node) => null;
   R visitMapLiteralEntry(MapLiteralEntry node) => null;
   R visitMethodDeclaration(MethodDeclaration node) => null;
   R visitMethodInvocation(MethodInvocation node) => null;
   R visitNamedExpression(NamedExpression node) => null;
+  R visitNativeFunctionBody(NativeFunctionBody node) => null;
   R visitNullLiteral(NullLiteral node) => null;
   R visitParenthesizedExpression(ParenthesizedExpression node) => null;
   R visitPartDirective(PartDirective node) => null;
   R visitPartOfDirective(PartOfDirective node) => null;
   R visitPostfixExpression(PostfixExpression node) => null;
   R visitPrefixedIdentifier(PrefixedIdentifier node) => null;
   R visitPrefixExpression(PrefixExpression node) => null;
   R visitPropertyAccess(PropertyAccess node) => null;
   R visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) => null;
   R visitRethrowExpression(RethrowExpression node) => null;
@@ skipping 287 matching lines @@
     visit(node.loopVariable);
     _writer.print(" in ");
     visit(node.iterator);
     _writer.print(") ");
     visit(node.body);
     return null;
   }
   Object visitFormalParameterList(FormalParameterList node) {
     String groupEnd = null;
     _writer.print('(');
-    NodeList<FormalParameter> parameters9 = node.parameters;
-    int size2 = parameters9.length;
+    NodeList<FormalParameter> parameters10 = node.parameters;
+    int size2 = parameters10.length;
     for (int i = 0; i < size2; i++) {
-      FormalParameter parameter = parameters9[i];
+      FormalParameter parameter = parameters10[i];
       if (i > 0) {
         _writer.print(", ");
       }
       if (groupEnd == null && parameter is DefaultFormalParameter) {
         if (identical(parameter.kind, ParameterKind.NAMED)) {
           groupEnd = "}";
           _writer.print('{');
         } else {
           groupEnd = "]";
           _writer.print('[');
@@ skipping 202 matching lines @@
     }
     visit(node.methodName);
     visit(node.argumentList);
     return null;
   }
   Object visitNamedExpression(NamedExpression node) {
     visit(node.name);
     visit3(" ", node.expression);
     return null;
   }
+  Object visitNativeFunctionBody(NativeFunctionBody node) {
+    _writer.print("native ");
+    visit(node.stringLiteral);
+    _writer.print(';');
+    return null;
+  }
   Object visitNullLiteral(NullLiteral node) {
     _writer.print("null");
     return null;
   }
   Object visitParenthesizedExpression(ParenthesizedExpression node) {
     _writer.print('(');
     visit(node.expression);
     _writer.print(')');
     return null;
   }
@@ skipping 297 matching lines @@
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 }
 /**
+ * Instances of the class {@code ASTCloner} implement an object that will clone any AST structure
+ * that it visits. The cloner will only clone the structure, it will not preserve any resolution
+ * results or properties associated with the nodes.
+ */
+class ASTCloner implements ASTVisitor<ASTNode> {
+  AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings.full(clone2(node.strings));
+  Annotation visitAnnotation(Annotation node) => new Annotation.full(node.atSign, clone(node.name), node.period, clone(node.constructorName), clone(node.arguments));
+  ArgumentDefinitionTest visitArgumentDefinitionTest(ArgumentDefinitionTest node) => new ArgumentDefinitionTest.full(node.question, clone(node.identifier));
+  ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList.full(node.leftParenthesis, clone2(node.arguments), node.rightParenthesis);
+  AsExpression visitAsExpression(AsExpression node) => new AsExpression.full(clone(node.expression), node.asOperator, clone(node.type));
+  ASTNode visitAssertStatement(AssertStatement node) => new AssertStatement.full(node.keyword, node.leftParenthesis, clone(node.condition), node.rightParenthesis, node.semicolon);
+  AssignmentExpression visitAssignmentExpression(AssignmentExpression node) => new AssignmentExpression.full(clone(node.leftHandSide), node.operator, clone(node.rightHandSide));
+  BinaryExpression visitBinaryExpression(BinaryExpression node) => new BinaryExpression.full(clone(node.leftOperand), node.operator, clone(node.rightOperand));
+  Block visitBlock(Block node) => new Block.full(node.leftBracket, clone2(node.statements), node.rightBracket);
+  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody.full(clone(node.block));
+  BooleanLiteral visitBooleanLiteral(BooleanLiteral node) => new BooleanLiteral.full(node.literal, node.value);
+  BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement.full(node.keyword, clone(node.label), node.semicolon);
+  CascadeExpression visitCascadeExpression(CascadeExpression node) => new CascadeExpression.full(clone(node.target), clone2(node.cascadeSections));
+  CatchClause visitCatchClause(CatchClause node) => new CatchClause.full(node.onKeyword, clone(node.exceptionType), node.catchKeyword, node.leftParenthesis, clone(node.exceptionParameter), node.comma, clone(node.stackTraceParameter), node.rightParenthesis, clone(node.body));
+  ClassDeclaration visitClassDeclaration(ClassDeclaration node) => new ClassDeclaration.full(clone(node.documentationComment), clone2(node.metadata), node.abstractKeyword, node.classKeyword, clone(node.name), clone(node.typeParameters), clone(node.extendsClause), clone(node.withClause), clone(node.implementsClause), node.leftBracket, clone2(node.members), node.rightBracket);
+  ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => new ClassTypeAlias.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.name), clone(node.typeParameters), node.equals, node.abstractKeyword, clone(node.superclass), clone(node.withClause), clone(node.implementsClause), node.semicolon);
+  Comment visitComment(Comment node) {
+    if (node.isDocumentation()) {
+      return Comment.createDocumentationComment2(node.tokens, clone2(node.references));
+    } else if (node.isBlock()) {
+      return Comment.createBlockComment(node.tokens);
+    }
+    return Comment.createEndOfLineComment(node.tokens);
+  }
+  CommentReference visitCommentReference(CommentReference node) => new CommentReference.full(node.newKeyword, clone(node.identifier));
+  CompilationUnit visitCompilationUnit(CompilationUnit node) {
+    CompilationUnit clone3 = new CompilationUnit.full(node.beginToken, clone(node.scriptTag), clone2(node.directives), clone2(node.declarations), node.endToken);
+    clone3.lineInfo = node.lineInfo;
+    clone3.parsingErrors = node.parsingErrors;
+    clone3.resolutionErrors = node.resolutionErrors;
+    return clone3;
+  }
+  ConditionalExpression visitConditionalExpression(ConditionalExpression node) => new ConditionalExpression.full(clone(node.condition), node.question, clone(node.thenExpression), node.colon, clone(node.elseExpression));
+  ConstructorDeclaration visitConstructorDeclaration(ConstructorDeclaration node) => new ConstructorDeclaration.full(clone(node.documentationComment), clone2(node.metadata), node.externalKeyword, node.constKeyword, node.factoryKeyword, clone(node.returnType), node.period, clone(node.name), clone(node.parameters), node.separator, clone2(node.initializers), clone(node.redirectedConstructor), clone(node.body));
+  ConstructorFieldInitializer visitConstructorFieldInitializer(ConstructorFieldInitializer node) => new ConstructorFieldInitializer.full(node.keyword, node.period, clone(node.fieldName), node.equals, clone(node.expression));
+  ConstructorName visitConstructorName(ConstructorName node) => new ConstructorName.full(clone(node.type), node.period, clone(node.name));
+  ContinueStatement visitContinueStatement(ContinueStatement node) => new ContinueStatement.full(node.keyword, clone(node.label), node.semicolon);
+  DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) => new DeclaredIdentifier.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.type), clone(node.identifier));
+  DefaultFormalParameter visitDefaultFormalParameter(DefaultFormalParameter node) => new DefaultFormalParameter.full(clone(node.parameter), node.kind, node.separator, clone(node.defaultValue));
+  DoStatement visitDoStatement(DoStatement node) => new DoStatement.full(node.doKeyword, clone(node.body), node.whileKeyword, node.leftParenthesis, clone(node.condition), node.rightParenthesis, node.semicolon);
+  DoubleLiteral visitDoubleLiteral(DoubleLiteral node) => new DoubleLiteral.full(node.literal, node.value);
+  EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) => new EmptyFunctionBody.full(node.semicolon);
+  EmptyStatement visitEmptyStatement(EmptyStatement node) => new EmptyStatement.full(node.semicolon);
+  ExportDirective visitExportDirective(ExportDirective node) => new ExportDirective.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.uri), clone2(node.combinators), node.semicolon);
+  ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody.full(node.functionDefinition, clone(node.expression), node.semicolon);
+  ExpressionStatement visitExpressionStatement(ExpressionStatement node) => new ExpressionStatement.full(clone(node.expression), node.semicolon);
+  ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause.full(node.keyword, clone(node.superclass));
+  FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => new FieldDeclaration.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.fields), node.semicolon);
+  FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => new FieldFormalParameter.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.type), node.thisToken, node.period, clone(node.identifier));
+  ForEachStatement visitForEachStatement(ForEachStatement node) => new ForEachStatement.full(node.forKeyword, node.leftParenthesis, clone(node.loopVariable), node.inKeyword, clone(node.iterator), node.rightParenthesis, clone(node.body));
+  FormalParameterList visitFormalParameterList(FormalParameterList node) => new FormalParameterList.full(node.leftParenthesis, clone2(node.parameters), node.leftDelimiter, node.rightDelimiter, node.rightParenthesis);
+  ForStatement visitForStatement(ForStatement node) => new ForStatement.full(node.forKeyword, node.leftParenthesis, clone(node.variables), clone(node.initialization), node.leftSeparator, clone(node.condition), node.rightSeparator, clone2(node.updaters), node.rightParenthesis, clone(node.body));
+  FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => new FunctionDeclaration.full(clone(node.documentationComment), clone2(node.metadata), node.externalKeyword, clone(node.returnType), node.propertyKeyword, clone(node.name), clone(node.functionExpression));
+  FunctionDeclarationStatement visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => new FunctionDeclarationStatement.full(clone(node.functionDeclaration));
+  FunctionExpression visitFunctionExpression(FunctionExpression node) => new FunctionExpression.full(clone(node.parameters), clone(node.body));
+  FunctionExpressionInvocation visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => new FunctionExpressionInvocation.full(clone(node.function), clone(node.argumentList));
+  FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => new FunctionTypeAlias.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.returnType), clone(node.name), clone(node.typeParameters), clone(node.parameters), node.semicolon);
+  FunctionTypedFormalParameter visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter.full(clone(node.documentationComment), clone2(node.metadata), clone(node.returnType), clone(node.identifier), clone(node.parameters));
+  HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator.full(node.keyword, clone2(node.hiddenNames));
+  IfStatement visitIfStatement(IfStatement node) => new IfStatement.full(node.ifKeyword, node.leftParenthesis, clone(node.condition), node.rightParenthesis, clone(node.thenStatement), node.elseKeyword, clone(node.elseStatement));
+  ImplementsClause visitImplementsClause(ImplementsClause node) => new ImplementsClause.full(node.keyword, clone2(node.interfaces));
+  ImportDirective visitImportDirective(ImportDirective node) => new ImportDirective.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.uri), node.asToken, clone(node.prefix), clone2(node.combinators), node.semicolon);
+  IndexExpression visitIndexExpression(IndexExpression node) {
+    Token period13 = node.period;
+    if (period13 == null) {
+      return new IndexExpression.forTarget_full(clone(node.array), node.leftBracket, clone(node.index), node.rightBracket);
+    } else {
+      return new IndexExpression.forCascade_full(period13, node.leftBracket, clone(node.index), node.rightBracket);
+    }
+  }
+  InstanceCreationExpression visitInstanceCreationExpression(InstanceCreationExpression node) => new InstanceCreationExpression.full(node.keyword, clone(node.constructorName), clone(node.argumentList));
+  IntegerLiteral visitIntegerLiteral(IntegerLiteral node) => new IntegerLiteral.full(node.literal, node.value);
+  InterpolationExpression visitInterpolationExpression(InterpolationExpression node) => new InterpolationExpression.full(node.leftBracket, clone(node.expression), node.rightBracket);
+  InterpolationString visitInterpolationString(InterpolationString node) => new InterpolationString.full(node.contents, node.value);
+  IsExpression visitIsExpression(IsExpression node) => new IsExpression.full(clone(node.expression), node.isOperator, node.notOperator, clone(node.type));
+  Label visitLabel(Label node) => new Label.full(clone(node.label), node.colon);
+  LabeledStatement visitLabeledStatement(LabeledStatement node) => new LabeledStatement.full(clone2(node.labels), clone(node.statement));
+  LibraryDirective visitLibraryDirective(LibraryDirective node) => new LibraryDirective.full(clone(node.documentationComment), clone2(node.metadata), node.libraryToken, clone(node.name), node.semicolon);
+  LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) => new LibraryIdentifier.full(clone2(node.components));
+  ListLiteral visitListLiteral(ListLiteral node) => new ListLiteral.full(node.modifier, clone(node.typeArguments), node.leftBracket, clone2(node.elements), node.rightBracket);
+  MapLiteral visitMapLiteral(MapLiteral node) => new MapLiteral.full(node.modifier, clone(node.typeArguments), node.leftBracket, clone2(node.entries), node.rightBracket);
+  MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) => new MapLiteralEntry.full(clone(node.key), node.separator, clone(node.value));
+  MethodDeclaration visitMethodDeclaration(MethodDeclaration node) => new MethodDeclaration.full(clone(node.documentationComment), clone2(node.metadata), node.externalKeyword, node.modifierKeyword, clone(node.returnType), node.propertyKeyword, node.operatorKeyword, clone(node.name), clone(node.parameters), clone(node.body));
+  MethodInvocation visitMethodInvocation(MethodInvocation node) => new MethodInvocation.full(clone(node.target), node.period, clone(node.methodName), clone(node.argumentList));
+  NamedExpression visitNamedExpression(NamedExpression node) => new NamedExpression.full(clone(node.name), clone(node.expression));
+  NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) => new NativeFunctionBody.full(node.nativeToken, clone(node.stringLiteral), node.semicolon);
+  NullLiteral visitNullLiteral(NullLiteral node) => new NullLiteral.full(node.literal);
+  ParenthesizedExpression visitParenthesizedExpression(ParenthesizedExpression node) => new ParenthesizedExpression.full(node.leftParenthesis, clone(node.expression), node.rightParenthesis);
+  PartDirective visitPartDirective(PartDirective node) => new PartDirective.full(clone(node.documentationComment), clone2(node.metadata), node.partToken, clone(node.uri), node.semicolon);
+  PartOfDirective visitPartOfDirective(PartOfDirective node) => new PartOfDirective.full(clone(node.documentationComment), clone2(node.metadata), node.partToken, node.ofToken, clone(node.libraryName), node.semicolon);
+  PostfixExpression visitPostfixExpression(PostfixExpression node) => new PostfixExpression.full(clone(node.operand), node.operator);
+  PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) => new PrefixedIdentifier.full(clone(node.prefix), node.period, clone(node.identifier));
+  PrefixExpression visitPrefixExpression(PrefixExpression node) => new PrefixExpression.full(node.operator, clone(node.operand));
+  PropertyAccess visitPropertyAccess(PropertyAccess node) => new PropertyAccess.full(clone(node.target), node.operator, clone(node.propertyName));
+  RedirectingConstructorInvocation visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) => new RedirectingConstructorInvocation.full(node.keyword, node.period, clone(node.constructorName), clone(node.argumentList));
+  RethrowExpression visitRethrowExpression(RethrowExpression node) => new RethrowExpression.full(node.keyword);
+  ReturnStatement visitReturnStatement(ReturnStatement node) => new ReturnStatement.full(node.keyword, clone(node.expression), node.semicolon);
+  ScriptTag visitScriptTag(ScriptTag node) => new ScriptTag.full(node.scriptTag);
+  ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator.full(node.keyword, clone2(node.shownNames));
+  SimpleFormalParameter visitSimpleFormalParameter(SimpleFormalParameter node) => new SimpleFormalParameter.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.type), clone(node.identifier));
+  SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) => new SimpleIdentifier.full(node.token);
+  SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) => new SimpleStringLiteral.full(node.literal, node.value);
+  StringInterpolation visitStringInterpolation(StringInterpolation node) => new StringInterpolation.full(clone2(node.elements));
+  SuperConstructorInvocation visitSuperConstructorInvocation(SuperConstructorInvocation node) => new SuperConstructorInvocation.full(node.keyword, node.period, clone(node.constructorName), clone(node.argumentList));
+  SuperExpression visitSuperExpression(SuperExpression node) => new SuperExpression.full(node.keyword);
+  SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase.full(clone2(node.labels), node.keyword, clone(node.expression), node.colon, clone2(node.statements));
+  SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault.full(clone2(node.labels), node.keyword, node.colon, clone2(node.statements));
+  SwitchStatement visitSwitchStatement(SwitchStatement node) => new SwitchStatement.full(node.keyword, node.leftParenthesis, clone(node.expression), node.rightParenthesis, node.leftBracket, clone2(node.members), node.rightBracket);
+  ThisExpression visitThisExpression(ThisExpression node) => new ThisExpression.full(node.keyword);
+  ThrowExpression visitThrowExpression(ThrowExpression node) => new ThrowExpression.full(node.keyword, clone(node.expression));
+  TopLevelVariableDeclaration visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration.full(clone(node.documentationComment), clone2(node.metadata), clone(node.variables), node.semicolon);
+  TryStatement visitTryStatement(TryStatement node) => new TryStatement.full(node.tryKeyword, clone(node.body), clone2(node.catchClauses), node.finallyKeyword, clone(node.finallyClause));
+  TypeArgumentList visitTypeArgumentList(TypeArgumentList node) => new TypeArgumentList.full(node.leftBracket, clone2(node.arguments), node.rightBracket);
+  TypeName visitTypeName(TypeName node) => new TypeName.full(clone(node.name), clone(node.typeArguments));
+  TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter.full(clone(node.documentationComment), clone2(node.metadata), clone(node.name), node.keyword, clone(node.bound));
+  TypeParameterList visitTypeParameterList(TypeParameterList node) => new TypeParameterList.full(node.leftBracket, clone2(node.typeParameters), node.rightBracket);
+  VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => new VariableDeclaration.full(clone(node.documentationComment), clone2(node.metadata), clone(node.name), node.equals, clone(node.initializer));
+  VariableDeclarationList visitVariableDeclarationList(VariableDeclarationList node) => new VariableDeclarationList.full(clone(node.documentationComment), clone2(node.metadata), node.keyword, clone(node.type), clone2(node.variables));
+  VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement.full(clone(node.variables), node.semicolon);
+  WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement.full(node.keyword, node.leftParenthesis, clone(node.condition), node.rightParenthesis, clone(node.body));
+  WithClause visitWithClause(WithClause node) => new WithClause.full(node.withKeyword, clone2(node.mixinTypes));
+  ASTNode clone(ASTNode node) {
+    if (node == null) {
+      return null;
+    }
+    return node.accept(this) as ASTNode;
+  }
+  List clone2(NodeList nodes) {
+    List clonedNodes = new List();
+    for (ASTNode node in nodes) {
+      clonedNodes.add((node.accept(this) as ASTNode));
+    }
+    return clonedNodes;
+  }
+}
+/**
  * Instances of the class {@code NodeList} represent a list of AST nodes that have a common parent.
  */
 class NodeList<E extends ASTNode> extends ListWrapper<E> {
   /**
    * The node that is the parent of each of the elements in the list.
    */
   ASTNode owner;
   /**
    * The elements of the list.
    */
@@ skipping 46 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;
   }
 }