Translate Java's @Override into Dart's @override.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.ast;
 
 import 'dart:collection';
@@ skipping 27 matching lines @@
   /**
    * Initialize a newly created list of adjacent strings.
    *
    * @param strings the strings that are implicitly concatenated
    */
   AdjacentStrings(List<StringLiteral> strings) {
     this._strings = new NodeList<StringLiteral>(this);
     this._strings.addAll(strings);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitAdjacentStrings(this);
 
+  @override
   Token get beginToken => _strings.beginToken;
 
+  @override
   Token get endToken => _strings.endToken;
 
   /**
    * Return the strings that are implicitly concatenated.
    *
    * @return the strings that are implicitly concatenated
    */
   NodeList<StringLiteral> get strings => _strings;
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _strings.accept(visitor);
   }
 
+  @override
   void appendStringValue(JavaStringBuilder builder) {
     for (StringLiteral stringLiteral in strings) {
       stringLiteral.appendStringValue(builder);
     }
   }
 }
 
 /**
  * The abstract class `AnnotatedNode` defines the behavior of nodes that can be annotated with
  * both a comment and metadata.
@@ skipping 15 matching lines @@
    *
    * @param comment the documentation comment associated with this node
    * @param metadata the annotations associated with this node
    */
   AnnotatedNode(Comment comment, List<Annotation> metadata) {
     this._metadata = new NodeList<Annotation>(this);
     this._comment = becomeParentOf(comment);
     this._metadata.addAll(metadata);
   }
 
+  @override
   Token get beginToken {
     if (_comment == null) {
       if (_metadata.isEmpty) {
         return firstTokenAfterCommentAndMetadata;
       } else {
         return _metadata.beginToken;
       }
     } else if (_metadata.isEmpty) {
       return _comment.beginToken;
     }
@@ skipping 32 matching lines @@
   /**
    * Set the metadata associated with this node to the given metadata.
    *
    * @param metadata the metadata to be associated with this node
    */
   void set metadata(List<Annotation> metadata) {
     this._metadata.clear();
     this._metadata.addAll(metadata);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     if (_commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (AstNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
   }
@@ skipping 95 matching lines @@
    *          annotation is not the invocation of a named constructor
    * @param arguments the arguments to the constructor being invoked, or `null` if this
    *          annotation is not the invocation of a constructor
    */
   Annotation(this.atSign, Identifier name, this.period, SimpleIdentifier constructorName, ArgumentList arguments) {
     this._name = becomeParentOf(name);
     this._constructorName = becomeParentOf(constructorName);
     this._arguments = becomeParentOf(arguments);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitAnnotation(this);
 
   /**
    * Return the arguments to the constructor being invoked, or `null` if this annotation is
    * not the invocation of a constructor.
    *
    * @return the arguments to the constructor being invoked
    */
   ArgumentList get arguments => _arguments;
 
+  @override
   Token get beginToken => atSign;
 
   /**
    * Return the name of the constructor being invoked, or `null` if this annotation is not the
    * invocation of a named constructor.
    *
    * @return the name of the constructor being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
 
   /**
    * Return the element associated with this annotation, or `null` if the AST structure has
    * not been resolved or if this annotation could not be resolved.
    *
    * @return the element associated with this annotation
    */
   Element get element {
     if (_element != null) {
       return _element;
     }
     if (_name != null) {
       return _name.staticElement;
     }
     return null;
   }
 
+  @override
   Token get endToken {
     if (_arguments != null) {
       return _arguments.endToken;
     } else if (_constructorName != null) {
       return _constructorName.endToken;
     }
     return _name.endToken;
   }
 
   /**
@@ skipping 34 matching lines @@
   /**
    * 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 name) {
     this._name = becomeParentOf(name);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_arguments, visitor);
   }
 }
 
 /**
  * Instances of the class `ArgumentDefinitionTest` represent an argument definition test.
  *
@@ skipping 16 matching lines @@
   /**
    * Initialize a newly created argument definition test.
    *
    * @param question the token representing the question mark
    * @param identifier the identifier representing the argument being tested
    */
   ArgumentDefinitionTest(this.question, SimpleIdentifier identifier) {
     this._identifier = becomeParentOf(identifier);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitArgumentDefinitionTest(this);
 
+  @override
   Token get beginToken => question;
 
+  @override
   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;
 
+  @override
   int get precedence => 15;
 
   /**
    * 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 identifier) {
     this._identifier = becomeParentOf(identifier);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 
 /**
  * Instances of the class `ArgumentList` represent a list of arguments in the invocation of a
  * executable element: a function, method, or constructor.
  *
  * <pre>
@@ skipping 46 matching lines @@
    * @param arguments the expressions producing the values of the arguments
    * @param rightParenthesis the right parenthesis
    */
   ArgumentList(Token leftParenthesis, List<Expression> arguments, Token rightParenthesis) {
     this._arguments = new NodeList<Expression>(this);
     this._leftParenthesis = leftParenthesis;
     this._arguments.addAll(arguments);
     this._rightParenthesis = rightParenthesis;
   }
 
+  @override
   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;
 
+  @override
   Token get beginToken => _leftParenthesis;
 
+  @override
   Token get endToken => _rightParenthesis;
 
   /**
    * Return the left parenthesis.
    *
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
 
   /**
@@ skipping 44 matching lines @@
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _arguments.accept(visitor);
   }
 
   /**
    * If the given expression is a child of this list, and the AST structure has been resolved, and
    * the function being invoked is known based on propagated type information, and the expression
    * corresponds to one of the parameters of the function being invoked, then return the parameter
    * element representing the parameter to which the value of the given expression will be bound.
    * Otherwise, return `null`.
@@ skipping 76 matching lines @@
    * @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._expression = becomeParentOf(expression);
     this.asOperator = isOperator;
     this._type = becomeParentOf(type);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitAsExpression(this);
 
+  @override
   Token get beginToken => _expression.beginToken;
 
+  @override
   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;
 
+  @override
   int get precedence => 7;
 
   /**
    * Return the name of the type being cast to.
    *
    * @return the name of the type being cast to
    */
   TypeName get type => _type;
 
   /**
    * 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 expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
   /**
    * 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 type(TypeName name) {
     this._type = becomeParentOf(name);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 
 /**
  * Instances of the class `AssertStatement` represent an assert statement.
  *
  * <pre>
@@ skipping 33 matching lines @@
    * @param keyword the token representing the 'assert' keyword
    * @param leftParenthesis the left parenthesis
    * @param condition the condition that is being asserted to be `true`
    * @param rightParenthesis the right parenthesis
    * @param semicolon the semicolon terminating the statement
    */
   AssertStatement(this.keyword, this.leftParenthesis, Expression condition, this.rightParenthesis, this.semicolon) {
     this._condition = becomeParentOf(condition);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitAssertStatement(this);
 
+  @override
   Token get beginToken => keyword;
 
   /**
    * Return the condition that is being asserted to be `true`.
    *
    * @return the condition that is being asserted to be `true`
    */
   Expression get condition => _condition;
 
+  @override
   Token get endToken => semicolon;
 
   /**
    * Set the condition that is being asserted to be `true` to the given expression.
    *
    * @param the condition that is being asserted to be `true`
    */
   void set condition(Expression condition) {
     this._condition = becomeParentOf(condition);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_condition, visitor);
   }
 }
 
 /**
  * Instances of the class `AssignmentExpression` represent an assignment expression.
  *
  * <pre>
  * assignmentExpression ::=
@@ skipping 35 matching lines @@
    *
    * @param leftHandSide the expression used to compute the left hand side
    * @param operator the assignment operator being applied
    * @param rightHandSide the expression used to compute the right hand side
    */
   AssignmentExpression(Expression leftHandSide, this.operator, Expression rightHandSide) {
     this._leftHandSide = becomeParentOf(leftHandSide);
     this._rightHandSide = becomeParentOf(rightHandSide);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitAssignmentExpression(this);
 
+  @override
   Token get beginToken => _leftHandSide.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
    * @return the best element available for this operator
    */
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
+  @override
   Token get endToken => _rightHandSide.endToken;
 
   /**
    * Set the expression used to compute the left hand side to the given expression.
    *
    * @return the expression used to compute the left hand side
    */
   Expression get leftHandSide => _leftHandSide;
 
+  @override
   int get precedence => 1;
 
   /**
    * Return the element associated with the operator based on the propagated type of the
    * left-hand-side, or `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
    */
@@ skipping 47 matching lines @@
   /**
    * Set the element associated with the operator based on the static type of the left-hand-side to
    * the given element.
    *
    * @param element the static element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_leftHandSide, visitor);
     safelyVisitChild(_rightHandSide, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the right operand will be bound. Otherwise, return `null`.
    *
@@ skipping 216 matching lines @@
    * string will not be valid source primarily in the case where the node itself is not well-formed.
    *
    * @return the source code equivalent of this node
    */
   String toSource() {
     PrintStringWriter writer = new PrintStringWriter();
     accept(new ToSourceVisitor(writer));
     return writer.toString();
   }
 
+  @override
   String toString() => toSource();
 
   /**
    * Use the given visitor to visit all of the children of this node. The children will be visited
    * in source order.
    *
    * @param visitor the visitor that will be used to visit the children of this node
    */
   void visitChildren(AstVisitor visitor);
 
@@ skipping 288 matching lines @@
    *
    * @param leftOperand the expression used to compute the left operand
    * @param operator the binary operator being applied
    * @param rightOperand the expression used to compute the right operand
    */
   BinaryExpression(Expression leftOperand, this.operator, Expression rightOperand) {
     this._leftOperand = becomeParentOf(leftOperand);
     this._rightOperand = becomeParentOf(rightOperand);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitBinaryExpression(this);
 
+  @override
   Token get beginToken => _leftOperand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
    * @return the best element available for this operator
    */
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
+  @override
   Token get endToken => _rightOperand.endToken;
 
   /**
    * Return the expression used to compute the left operand.
    *
    * @return the expression used to compute the left operand
    */
   Expression get leftOperand => _leftOperand;
 
+  @override
   int get precedence => operator.type.precedence;
 
   /**
    * Return the element associated with the operator based on the propagated type of the left
    * operand, or `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
    */
@@ skipping 47 matching lines @@
   /**
    * Set the element associated with the operator based on the static type of the left operand to
    * the given element.
    *
    * @param element the static element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_leftOperand, visitor);
     safelyVisitChild(_rightOperand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the right operand will be bound. Otherwise, return `null`.
    *
@@ skipping 64 matching lines @@
    *
    * @param leftBracket the left curly bracket
    * @param statements the statements contained in the block
    * @param rightBracket the right curly bracket
    */
   Block(this.leftBracket, List<Statement> statements, this.rightBracket) {
     this._statements = new NodeList<Statement>(this);
     this._statements.addAll(statements);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitBlock(this);
 
+  @override
   Token get beginToken => leftBracket;
 
+  @override
   Token get endToken => rightBracket;
 
   /**
    * Return the statements contained in the block.
    *
    * @return the statements contained in the block
    */
   NodeList<Statement> get statements => _statements;
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _statements.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `BlockFunctionBody` represent a function body that consists of a
  * block of statements.
  *
  * <pre>
  * blockFunctionBody ::=
  *     [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) {
     this._block = becomeParentOf(block);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitBlockFunctionBody(this);
 
+  @override
   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;
 
+  @override
   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 block(Block block) {
     this._block = becomeParentOf(block);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_block, visitor);
   }
 }
 
 /**
  * Instances of the class `BooleanLiteral` represent a boolean literal expression.
  *
  * <pre>
  * booleanLiteral ::=
@@ skipping 12 matching lines @@
   bool value = false;
 
   /**
    * Initialize a newly created boolean literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   BooleanLiteral(this.literal, this.value);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitBooleanLiteral(this);
 
+  @override
   Token get beginToken => literal;
 
+  @override
   Token get endToken => literal;
 
+  @override
   bool get isSynthetic => literal.isSynthetic;
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `BreakStatement` represent a break statement.
  *
  * <pre>
  * breakStatement ::=
  *     'break' [SimpleIdentifier]? ';'
@@ skipping 19 matching lines @@
    * Initialize a newly created break statement.
    *
    * @param keyword the token representing the 'break' keyword
    * @param label the label associated with the statement
    * @param semicolon the semicolon terminating the statement
    */
   BreakStatement(this.keyword, SimpleIdentifier label, this.semicolon) {
     this._label = becomeParentOf(label);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitBreakStatement(this);
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   Token get endToken => semicolon;
 
   /**
    * Return the label associated with the statement, or `null` if there is no label.
    *
    * @return the label associated with the statement
    */
   SimpleIdentifier get label => _label;
 
   /**
    * Set the label associated with the statement to the given identifier.
    *
    * @param identifier the label associated with the statement
    */
   void set label(SimpleIdentifier identifier) {
     _label = becomeParentOf(identifier);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 
 /**
  * Instances of the class `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: [IndexExpression], [MethodInvocation] and
  * [PropertyAccess].
@@ skipping 26 matching lines @@
    *
    * @param target the target of the cascade sections
    * @param cascadeSections the cascade sections sharing the common target
    */
   CascadeExpression(Expression target, List<Expression> cascadeSections) {
     this._cascadeSections = new NodeList<Expression>(this);
     this._target = becomeParentOf(target);
     this._cascadeSections.addAll(cascadeSections);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitCascadeExpression(this);
 
+  @override
   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;
 
+  @override
   Token get endToken => _cascadeSections.endToken;
 
+  @override
   int get precedence => 2;
 
   /**
    * Return the target of the cascade sections.
    *
    * @return the target of the cascade sections
    */
   Expression get target => _target;
 
   /**
    * Set the target of the cascade sections to the given expression.
    *
    * @param target the target of the cascade sections
    */
   void set target(Expression target) {
     this._target = becomeParentOf(target);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_target, visitor);
     _cascadeSections.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `CatchClause` represent a catch clause within a try statement.
  *
  * <pre>
@@ skipping 69 matching lines @@
    */
   CatchClause(this.onKeyword, TypeName exceptionType, this.catchKeyword, Token leftParenthesis, SimpleIdentifier exceptionParameter, this.comma, SimpleIdentifier stackTraceParameter, Token rightParenthesis, Block body) {
     this.exceptionType = becomeParentOf(exceptionType);
     this._leftParenthesis = leftParenthesis;
     this._exceptionParameter = becomeParentOf(exceptionParameter);
     this._stackTraceParameter = becomeParentOf(stackTraceParameter);
     this._rightParenthesis = rightParenthesis;
     this._body = becomeParentOf(body);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitCatchClause(this);
 
+  @override
   Token get beginToken {
     if (onKeyword != null) {
       return onKeyword;
     }
     return catchKeyword;
   }
 
   /**
    * Return the body of the catch block.
    *
    * @return the body of the catch block
    */
   Block get body => _body;
 
+  @override
   Token get endToken => _body.endToken;
 
   /**
    * Return the parameter whose value will be the exception that was thrown.
    *
    * @return the parameter whose value will be the exception that was thrown
    */
   SimpleIdentifier get exceptionParameter => _exceptionParameter;
 
   /**
@@ skipping 58 matching lines @@
    * 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 stackTraceParameter(SimpleIdentifier parameter) {
     _stackTraceParameter = becomeParentOf(parameter);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(exceptionType, visitor);
     safelyVisitChild(_exceptionParameter, visitor);
     safelyVisitChild(_stackTraceParameter, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * Instances of the class `ClassDeclaration` represent the declaration of a class.
@@ skipping 83 matching lines @@
   ClassDeclaration(Comment comment, List<Annotation> metadata, this.abstractKeyword, this.classKeyword, SimpleIdentifier name, TypeParameterList typeParameters, ExtendsClause extendsClause, WithClause withClause, ImplementsClause implementsClause, this.leftBracket, List<ClassMember> members, this.rightBracket) : super(comment, metadata) {
     this._members = new NodeList<ClassMember>(this);
     this._name = becomeParentOf(name);
     this.typeParameters = becomeParentOf(typeParameters);
     this._extendsClause = becomeParentOf(extendsClause);
     this._withClause = becomeParentOf(withClause);
     this._implementsClause = becomeParentOf(implementsClause);
     this._members.addAll(members);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitClassDeclaration(this);
 
   /**
    * Return the constructor declared in the class with the given name.
    *
    * @param name the name of the constructor to find, `null` for default
    * @return the found constructor or `null` if not found
    */
   ConstructorDeclaration getConstructor(String name) {
     for (ClassMember classMember in _members) {
       if (classMember is ConstructorDeclaration) {
         ConstructorDeclaration constructor = classMember;
         SimpleIdentifier constructorName = constructor.name;
         if (name == null && constructorName == null) {
           return constructor;
         }
         if (constructorName != null && constructorName.name == name) {
           return constructor;
         }
       }
     }
     return null;
   }
 
+  @override
   ClassElement get element => _name != null ? (_name.staticElement as ClassElement) : null;
 
+  @override
   Token get endToken => rightBracket;
 
   /**
    * Return the extends clause for this class, or `null` if the class does not extend any
    * other class.
    *
    * @return the extends clause for this class
    */
   ExtendsClause get extendsClause => _extendsClause;
 
@@ skipping 96 matching lines @@
 
   /**
    * Set the with clause for the class to the given clause.
    *
    * @param withClause the with clause for the class
    */
   void set withClause(WithClause withClause) {
     this._withClause = becomeParentOf(withClause);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(typeParameters, visitor);
     safelyVisitChild(_extendsClause, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
     safelyVisitChild(nativeClause, visitor);
     members.accept(visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata {
     if (abstractKeyword != null) {
       return abstractKeyword;
     }
     return classKeyword;
   }
 }
 
 /**
  * The abstract class `ClassMember` defines the behavior common to nodes that declare a name
@@ skipping 74 matching lines @@
    * @param semicolon the semicolon terminating the declaration
    */
   ClassTypeAlias(Comment comment, List<Annotation> metadata, Token keyword, SimpleIdentifier name, TypeParameterList typeParameters, this.equals, this.abstractKeyword, TypeName superclass, WithClause withClause, ImplementsClause implementsClause, Token semicolon) : super(comment, metadata, keyword, semicolon) {
     this._name = becomeParentOf(name);
     this._typeParameters = becomeParentOf(typeParameters);
     this._superclass = becomeParentOf(superclass);
     this._withClause = becomeParentOf(withClause);
     this._implementsClause = becomeParentOf(implementsClause);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitClassTypeAlias(this);
 
+  @override
   ClassElement get element => _name != null ? (_name.staticElement as ClassElement) : null;
 
   /**
    * Return the implements clause for this class, or `null` if there is no implements clause.
    *
    * @return the implements clause for this class
    */
   ImplementsClause get implementsClause => _implementsClause;
 
   /**
@@ skipping 63 matching lines @@
 
   /**
    * Set the with clause for this class to the given with clause.
    *
    * @param withClause the with clause for this class
    */
   void set withClause(WithClause withClause) {
     this._withClause = becomeParentOf(withClause);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_superclass, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
   }
 }
 
@@ skipping 14 matching lines @@
   Token keyword;
 
   /**
    * Initialize a newly created import combinator.
    *
    * @param keyword the keyword specifying what kind of processing is to be done on the imported
    *          names
    */
   Combinator(this.keyword);
 
+  @override
   Token get beginToken => keyword;
 }
 
 /**
  * Instances of the class `Comment` represent a comment within the source code.
  *
  * <pre>
  * comment ::=
  *     endOfLineComment
  *   | blockComment
@@ skipping 66 matching lines @@
    * @param tokens the tokens representing the comment
    * @param type the type of the comment
    * @param references the references embedded within the documentation comment
    */
   Comment(this.tokens, CommentType type, List<CommentReference> references) {
     this._references = new NodeList<CommentReference>(this);
     this._type = type;
     this._references.addAll(references);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitComment(this);
 
+  @override
   Token get beginToken => tokens[0];
 
+  @override
   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;
 
   /**
@@ skipping 10 matching lines @@
    */
   bool get isDocumentation => identical(_type, CommentType.DOCUMENTATION);
 
   /**
    * Return `true` if this is an end-of-line comment.
    *
    * @return `true` if this is an end-of-line comment
    */
   bool get isEndOfLine => identical(_type, CommentType.END_OF_LINE);
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _references.accept(visitor);
   }
 }
 
 /**
  * The enumeration `CommentType` encodes all the different types of comments that are
  * recognized by the parser.
  */
 class CommentType extends Enum<CommentType> {
@@ skipping 40 matching lines @@
   /**
    * Initialize a newly created reference to a Dart element.
    *
    * @param newKeyword the token representing the 'new' keyword
    * @param identifier the identifier being referenced
    */
   CommentReference(this.newKeyword, Identifier identifier) {
     this._identifier = becomeParentOf(identifier);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitCommentReference(this);
 
+  @override
   Token get beginToken => _identifier.beginToken;
 
+  @override
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the identifier being referenced.
    *
    * @return the identifier being referenced
    */
   Identifier get identifier => _identifier;
 
   /**
    * Set the identifier being referenced to the given identifier.
    *
    * @param identifier the identifier being referenced
    */
   void set identifier(Identifier identifier) {
     identifier = becomeParentOf(identifier);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_identifier, visitor);
   }
 }
 
 /**
  * Instances of the class `CompilationUnit` represent a compilation unit.
  *
  * 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 65 matching lines @@
    * @param endToken the last token in the token stream
    */
   CompilationUnit(this.beginToken, ScriptTag scriptTag, List<Directive> directives, List<CompilationUnitMember> declarations, this.endToken) {
     this._directives = new NodeList<Directive>(this);
     this._declarations = new NodeList<CompilationUnitMember>(this);
     this._scriptTag = becomeParentOf(scriptTag);
     this._directives.addAll(directives);
     this._declarations.addAll(declarations);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitCompilationUnit(this);
 
   /**
    * 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;
 
+  @override
   int get length {
     Token endToken = this.endToken;
     if (endToken == null) {
       return 0;
     }
     return endToken.offset + endToken.length;
   }
 
+  @override
   int get offset => 0;
 
   /**
    * Return the script tag at the beginning of the compilation unit, or `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;
 
   /**
    * 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 scriptTag) {
     this._scriptTag = becomeParentOf(scriptTag);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_scriptTag, visitor);
     if (_directivesAreBeforeDeclarations()) {
       _directives.accept(visitor);
       _declarations.accept(visitor);
     } else {
       for (AstNode child in sortedDirectivesAndDeclarations) {
         child.accept(visitor);
       }
     }
@@ skipping 98 matching lines @@
    * @param colon the token used to separate the then expression from the else expression
    * @param elseExpression the expression that is executed if the condition evaluates to
    *          `false`
    */
   ConditionalExpression(Expression condition, this.question, Expression thenExpression, this.colon, Expression elseExpression) {
     this._condition = becomeParentOf(condition);
     this._thenExpression = becomeParentOf(thenExpression);
     this._elseExpression = becomeParentOf(elseExpression);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitConditionalExpression(this);
 
+  @override
   Token get beginToken => _condition.beginToken;
 
   /**
    * Return the condition used to determine which of the expressions is executed next.
    *
    * @return the condition used to determine which expression is executed next
    */
   Expression get condition => _condition;
 
   /**
    * Return the expression that is executed if the condition evaluates to `false`.
    *
    * @return the expression that is executed if the condition evaluates to `false`
    */
   Expression get elseExpression => _elseExpression;
 
+  @override
   Token get endToken => _elseExpression.endToken;
 
+  @override
   int get precedence => 3;
 
   /**
    * Return the expression that is executed if the condition evaluates to `true`.
    *
    * @return the expression that is executed if the condition evaluates to `true`
    */
   Expression get thenExpression => _thenExpression;
 
   /**
@@ skipping 19 matching lines @@
   /**
    * Set the expression that is executed if the condition evaluates to `true` to the given
    * expression.
    *
    * @param expression the expression that is executed if the condition evaluates to `true`
    */
   void set thenExpression(Expression expression) {
     _thenExpression = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_thenExpression, visitor);
     safelyVisitChild(_elseExpression, visitor);
   }
 }
 
 /**
  * Instances of the class `ConstructorDeclaration` represent a constructor declaration.
  *
@@ skipping 106 matching lines @@
   ConstructorDeclaration(Comment comment, List<Annotation> metadata, this.externalKeyword, this.constKeyword, this.factoryKeyword, Identifier returnType, this.period, SimpleIdentifier name, FormalParameterList parameters, this.separator, List<ConstructorInitializer> initializers, ConstructorName redirectedConstructor, FunctionBody body) : super(comment, metadata) {
     this._initializers = new NodeList<ConstructorInitializer>(this);
     this._returnType = becomeParentOf(returnType);
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
     this._initializers.addAll(initializers);
     this._redirectedConstructor = becomeParentOf(redirectedConstructor);
     this._body = becomeParentOf(body);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitConstructorDeclaration(this);
 
   /**
    * Return the body of the constructor, or `null` if the constructor does not have a body.
    *
    * @return the body of the constructor
    */
   FunctionBody get body => _body;
 
+  @override
   Token get endToken {
     if (_body != null) {
       return _body.endToken;
     } else if (!_initializers.isEmpty) {
       return _initializers.endToken;
     }
     return _parameters.endToken;
   }
 
   /**
@@ skipping 75 matching lines @@
 
   /**
    * Set the type of object being created to the given type name.
    *
    * @param typeName the type of object being created
    */
   void set returnType(Identifier typeName) {
     _returnType = becomeParentOf(typeName);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_parameters, visitor);
     _initializers.accept(visitor);
     safelyVisitChild(_redirectedConstructor, visitor);
     safelyVisitChild(_body, visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata {
     Token leftMost = _leftMost([externalKeyword, constKeyword, factoryKeyword]);
     if (leftMost != null) {
       return leftMost;
     }
     return _returnType.beginToken;
   }
 
   /**
    * Return the left-most of the given tokens, or `null` if there are no tokens given or if
@@ skipping 58 matching lines @@
    * @param period the token for the period after the 'this' keyword
    * @param fieldName the name of the field being initialized
    * @param equals the token for the equal sign between the field name and the expression
    * @param expression the expression computing the value to which the field will be initialized
    */
   ConstructorFieldInitializer(this.keyword, this.period, SimpleIdentifier fieldName, this.equals, Expression expression) {
     this._fieldName = becomeParentOf(fieldName);
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitConstructorFieldInitializer(this);
 
+  @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     }
     return _fieldName.beginToken;
   }
 
+  @override
   Token get endToken => _expression.endToken;
 
   /**
    * Return the expression computing the value to which the field will be initialized.
    *
    * @return the expression computing the value to which the field will be initialized
    */
   Expression get expression => _expression;
 
   /**
@@ skipping 15 matching lines @@
 
   /**
    * Set the name of the field being initialized to the given identifier.
    *
    * @param identifier the name of the field being initialized
    */
   void set fieldName(SimpleIdentifier identifier) {
     _fieldName = becomeParentOf(identifier);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_fieldName, visitor);
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `ConstructorInitializer` defines the behavior of nodes that can
  * occur in the initializer list of a constructor declaration.
  *
@@ skipping 44 matching lines @@
    *
    * @param type the name of the type defining the constructor
    * @param period the token for the period before the constructor name
    * @param name the name of the constructor
    */
   ConstructorName(TypeName type, this.period, SimpleIdentifier name) {
     this._type = becomeParentOf(type);
     this._name = becomeParentOf(name);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitConstructorName(this);
 
+  @override
   Token get beginToken => _type.beginToken;
 
+  @override
   Token get endToken {
     if (_name != null) {
       return _name.endToken;
     }
     return _type.endToken;
   }
 
   /**
    * Return the name of the constructor, or `null` if the specified constructor is the unnamed
    * constructor.
@@ skipping 39 matching lines @@
 
   /**
    * 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 type(TypeName type) {
     this._type = becomeParentOf(type);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_type, visitor);
     safelyVisitChild(_name, visitor);
   }
 }
 
 /**
  * Instances of the class `ContinueStatement` represent a continue statement.
  *
  * <pre>
@@ skipping 21 matching lines @@
    * Initialize a newly created continue statement.
    *
    * @param keyword the token representing the 'continue' keyword
    * @param label the label associated with the statement
    * @param semicolon the semicolon terminating the statement
    */
   ContinueStatement(this.keyword, SimpleIdentifier label, this.semicolon) {
     this._label = becomeParentOf(label);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitContinueStatement(this);
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   Token get endToken => semicolon;
 
   /**
    * Return the label associated with the statement, or `null` if there is no label.
    *
    * @return the label associated with the statement
    */
   SimpleIdentifier get label => _label;
 
   /**
    * Set the label associated with the statement to the given label.
    *
    * @param identifier the label associated with the statement
    */
   void set label(SimpleIdentifier identifier) {
     _label = becomeParentOf(identifier);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 
 /**
  * The abstract class `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 {
@@ skipping 48 matching lines @@
    * @param metadata the annotations associated with this parameter
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    * @param type the name of the declared type of the parameter
    * @param identifier the name of the parameter being declared
    */
   DeclaredIdentifier(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, SimpleIdentifier identifier) : super(comment, metadata) {
     this._type = becomeParentOf(type);
     this._identifier = becomeParentOf(identifier);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitDeclaredIdentifier(this);
 
+  @override
   LocalVariableElement get element {
     SimpleIdentifier identifier = this.identifier;
     if (identifier == null) {
       return null;
     }
     return identifier.staticElement as LocalVariableElement;
   }
 
+  @override
   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;
 
   /**
@@ skipping 22 matching lines @@
 
   /**
    * 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 type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(_identifier, visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return _identifier.beginToken;
   }
 }
 
@@ skipping 39 matching lines @@
    * @param parameter the formal parameter with which the default value is associated
    * @param kind the kind of this parameter
    * @param separator the token separating the parameter from the default value
    * @param defaultValue the expression computing the default value for the parameter
    */
   DefaultFormalParameter(NormalFormalParameter parameter, this.kind, this.separator, Expression defaultValue) {
     this._parameter = becomeParentOf(parameter);
     this._defaultValue = becomeParentOf(defaultValue);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitDefaultFormalParameter(this);
 
+  @override
   Token get beginToken => _parameter.beginToken;
 
   /**
    * Return the expression computing the default value for the parameter, or `null` if there
    * is no default value.
    *
    * @return the expression computing the default value for the parameter
    */
   Expression get defaultValue => _defaultValue;
 
+  @override
   Token get endToken {
     if (_defaultValue != null) {
       return _defaultValue.endToken;
     }
     return _parameter.endToken;
   }
 
+  @override
   SimpleIdentifier get identifier => _parameter.identifier;
 
   /**
    * Return the formal parameter with which the default value is associated.
    *
    * @return the formal parameter with which the default value is associated
    */
   NormalFormalParameter get parameter => _parameter;
 
+  @override
   bool get isConst => _parameter != null && _parameter.isConst;
 
+  @override
   bool get isFinal => _parameter != null && _parameter.isFinal;
 
   /**
    * Set the expression computing the default value for the parameter to the given expression.
    *
    * @param expression the expression computing the default value for the parameter
    */
   void set defaultValue(Expression expression) {
     _defaultValue = becomeParentOf(expression);
   }
 
   /**
    * Set the formal parameter with which the default value is associated to the given parameter.
    *
    * @param formalParameter the formal parameter with which the default value is associated
    */
   void set parameter(NormalFormalParameter formalParameter) {
     _parameter = becomeParentOf(formalParameter);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_parameter, visitor);
     safelyVisitChild(_defaultValue, visitor);
   }
 }
 
 /**
  * The abstract class `Directive` defines the behavior common to nodes that represent a
  * directive.
  *
@@ skipping 103 matching lines @@
    * @param rightParenthesis the right parenthesis
    * @param semicolon the semicolon terminating the statement
    */
   DoStatement(this.doKeyword, Statement body, this.whileKeyword, Token leftParenthesis, Expression condition, Token rightParenthesis, this.semicolon) {
     this._body = becomeParentOf(body);
     this._leftParenthesis = leftParenthesis;
     this._condition = becomeParentOf(condition);
     this._rightParenthesis = rightParenthesis;
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitDoStatement(this);
 
+  @override
   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
    */
   Expression get condition => _condition;
 
+  @override
   Token get endToken => semicolon;
 
   /**
    * Return the left parenthesis.
    *
    * @return the left parenthesis
    */
   Token get leftParenthesis => _leftParenthesis;
 
   /**
@@ skipping 32 matching lines @@
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_body, visitor);
     safelyVisitChild(_condition, visitor);
   }
 }
 
 /**
  * Instances of the class `DoubleLiteral` represent a floating point literal expression.
  *
  * <pre>
@@ skipping 17 matching lines @@
   double value = 0.0;
 
   /**
    * Initialize a newly created floating point literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   DoubleLiteral(this.literal, this.value);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitDoubleLiteral(this);
 
+  @override
   Token get beginToken => literal;
 
+  @override
   Token get endToken => literal;
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `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(this.semicolon);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitEmptyFunctionBody(this);
 
+  @override
   Token get beginToken => semicolon;
 
+  @override
   Token get endToken => semicolon;
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `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(this.semicolon);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitEmptyStatement(this);
 
+  @override
   Token get beginToken => semicolon;
 
+  @override
   Token get endToken => semicolon;
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Ephemeral identifiers are created as needed to mimic the presence of an empty identifier.
  */
 class EphemeralIdentifier extends SimpleIdentifier {
   EphemeralIdentifier(AstNode parent, int location) : super(new StringToken(TokenType.IDENTIFIER, "", location)) {
     parent.becomeParentOf(this);
@@ skipping 14 matching lines @@
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param keyword the token representing the '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);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitExportDirective(this);
 
+  @override
   ExportElement get element => super.element as ExportElement;
 
+  @override
   LibraryElement get uriElement {
     ExportElement exportElement = element;
     if (exportElement != null) {
       return exportElement.exportedLibrary;
     }
     return null;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     combinators.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `Expression` defines the behavior common to nodes that represent an
  * expression.
  *
@@ skipping 180 matching lines @@
    *
    * @param functionDefinition the token introducing the expression that represents the body of the
    *          function
    * @param expression the expression representing the body of the function
    * @param semicolon the semicolon terminating the statement
    */
   ExpressionFunctionBody(this.functionDefinition, Expression expression, this.semicolon) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitExpressionFunctionBody(this);
 
+  @override
   Token get beginToken => functionDefinition;
 
+  @override
   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;
 
   /**
    * 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 expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `ExpressionStatement` wrap an expression as a statement.
  *
  * <pre>
  * expressionStatement ::=
@@ skipping 15 matching lines @@
   /**
    * Initialize a newly created expression statement.
    *
    * @param expression the expression that comprises the statement
    * @param semicolon the semicolon terminating the statement
    */
   ExpressionStatement(Expression expression, this.semicolon) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitExpressionStatement(this);
 
+  @override
   Token get beginToken => _expression.beginToken;
 
+  @override
   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;
 
+  @override
   bool get 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 expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `ExtendsClause` represent the "extends" clause in a class
  * declaration.
  *
  * <pre>
@@ skipping 15 matching lines @@
   /**
    * Initialize a newly created extends clause.
    *
    * @param keyword the token representing the 'extends' keyword
    * @param superclass the name of the class that is being extended
    */
   ExtendsClause(this.keyword, TypeName superclass) {
     this._superclass = becomeParentOf(superclass);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitExtendsClause(this);
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   Token get endToken => _superclass.endToken;
 
   /**
    * Return the name of the class that is being extended.
    *
    * @return the name of the class that is being extended
    */
   TypeName get superclass => _superclass;
 
   /**
    * 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 superclass(TypeName name) {
     _superclass = becomeParentOf(name);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_superclass, visitor);
   }
 }
 
 /**
  * Instances of the class `FieldDeclaration` represent the declaration of one or more fields
  * of the same type.
  *
  * <pre>
@@ skipping 23 matching lines @@
    * @param comment the documentation comment associated with this field
    * @param metadata the annotations associated with this field
    * @param staticKeyword the token representing the 'static' keyword
    * @param fieldList the fields being declared
    * @param semicolon the semicolon terminating the declaration
    */
   FieldDeclaration(Comment comment, List<Annotation> metadata, this.staticKeyword, VariableDeclarationList fieldList, this.semicolon) : super(comment, metadata) {
     this._fieldList = becomeParentOf(fieldList);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitFieldDeclaration(this);
 
+  @override
   Element get element => null;
 
+  @override
   Token get endToken => semicolon;
 
   /**
    * Return the fields being declared.
    *
    * @return the fields being declared
    */
   VariableDeclarationList get fields => _fieldList;
 
   /**
    * Return `true` if the fields are static.
    *
    * @return `true` if the fields are declared to be static
    */
   bool get isStatic => staticKeyword != null;
 
   /**
    * Set the fields being declared to the given list of variables.
    *
    * @param fieldList the fields being declared
    */
   void set fields(VariableDeclarationList fieldList) {
     fieldList = becomeParentOf(fieldList);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_fieldList, visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata {
     if (staticKeyword != null) {
       return staticKeyword;
     }
     return _fieldList.beginToken;
   }
 }
 
 /**
  * Instances of the class `FieldFormalParameter` represent a field formal parameter.
@@ skipping 43 matching lines @@
    * @param period the token representing the period
    * @param identifier the name of the parameter being declared
    * @param parameters the parameters of the function-typed parameter, or `null` if this is
    *          not a function-typed field formal parameter
    */
   FieldFormalParameter(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, this.thisToken, this.period, SimpleIdentifier identifier, FormalParameterList parameters) : super(comment, metadata, identifier) {
     this._type = becomeParentOf(type);
     this._parameters = becomeParentOf(parameters);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitFieldFormalParameter(this);
 
+  @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return thisToken;
   }
 
+  @override
   Token get endToken => identifier.endToken;
 
   /**
    * Return the parameters of the function-typed parameter, or `null` if this is not a
    * function-typed field formal parameter.
    *
    * @return the parameters of the function-typed parameter
    */
   FormalParameterList get parameters => _parameters;
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the parameter does
    * not have a declared type. Note that if this is a function-typed field formal parameter this is
    * the return type of the function.
    *
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
 
+  @override
   bool get isConst => (keyword is KeywordToken) && identical((keyword as KeywordToken).keyword, Keyword.CONST);
 
+  @override
   bool get isFinal => (keyword is KeywordToken) && identical((keyword as KeywordToken).keyword, Keyword.FINAL);
 
   /**
    * Set the parameters of the function-typed parameter to the given parameters.
    *
    * @param parameters the parameters of the function-typed parameter
    */
   void set parameters(FormalParameterList parameters) {
     this._parameters = becomeParentOf(parameters);
   }
 
   /**
    * 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 type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * Instances of the class `ForEachStatement` represent a for-each statement.
@@ skipping 71 matching lines @@
    * @param iterator the expression evaluated to produce the iterator
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
   ForEachStatement.con2(this.forKeyword, this.leftParenthesis, SimpleIdentifier identifier, this.inKeyword, Expression iterator, this.rightParenthesis, Statement body) {
     this._identifier = becomeParentOf(identifier);
     this._iterator = becomeParentOf(iterator);
     this._body = becomeParentOf(body);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitForEachStatement(this);
 
+  @override
   Token get beginToken => forKeyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
 
+  @override
   Token get endToken => _body.endToken;
 
   /**
    * Return the loop variable, or `null` if the loop variable is declared in the 'for'.
    *
    * @return the loop variable
    */
   SimpleIdentifier get identifier => _identifier;
 
   /**
@@ skipping 40 matching lines @@
 
   /**
    * Set the declaration of the loop variable to the given variable.
    *
    * @param variable the declaration of the loop variable
    */
   void set loopVariable(DeclaredIdentifier variable) {
     _loopVariable = becomeParentOf(variable);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_loopVariable, visitor);
     safelyVisitChild(_identifier, visitor);
     safelyVisitChild(_iterator, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * Instances of the class `ForStatement` represent a for statement.
@@ skipping 82 matching lines @@
    */
   ForStatement(this.forKeyword, this.leftParenthesis, VariableDeclarationList variableList, Expression initialization, this.leftSeparator, Expression condition, this.rightSeparator, List<Expression> updaters, this.rightParenthesis, Statement body) {
     this._updaters = new NodeList<Expression>(this);
     this._variableList = becomeParentOf(variableList);
     this._initialization = becomeParentOf(initialization);
     this._condition = becomeParentOf(condition);
     this._updaters.addAll(updaters);
     this._body = becomeParentOf(body);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitForStatement(this);
 
+  @override
   Token get beginToken => forKeyword;
 
   /**
    * Return the body of the loop.
    *
    * @return the body of the loop
    */
   Statement get body => _body;
 
   /**
    * Return the condition used to determine when to terminate the loop, or `null` if there is
    * no condition.
    *
    * @return the condition used to determine when to terminate the loop
    */
   Expression get condition => _condition;
 
+  @override
   Token get endToken => _body.endToken;
 
   /**
    * Return the initialization expression, or `null` if there is no initialization expression.
    *
    * @return the initialization expression
    */
   Expression get initialization => _initialization;
 
   /**
@@ skipping 39 matching lines @@
 
   /**
    * Set the declaration of the loop variables to the given parameter.
    *
    * @param variableList the declaration of the loop variables
    */
   void set variables(VariableDeclarationList variableList) {
     variableList = becomeParentOf(variableList);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_variableList, visitor);
     safelyVisitChild(_initialization, visitor);
     safelyVisitChild(_condition, visitor);
     _updaters.accept(visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
@@ skipping 121 matching lines @@
    */
   FormalParameterList(Token leftParenthesis, List<FormalParameter> parameters, Token leftDelimiter, Token rightDelimiter, Token rightParenthesis) {
     this._parameters = new NodeList<FormalParameter>(this);
     this._leftParenthesis = leftParenthesis;
     this._parameters.addAll(parameters);
     this._leftDelimiter = leftDelimiter;
     this._rightDelimiter = rightDelimiter;
     this._rightParenthesis = rightParenthesis;
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitFormalParameterList(this);
 
+  @override
   Token get beginToken => _leftParenthesis;
 
+  @override
   Token get endToken => _rightParenthesis;
 
   /**
    * Return the left square bracket ('[') or left curly brace ('{') introducing the optional
    * parameters, or `null` if there are no optional parameters.
    *
    * @return the left square bracket ('[') or left curly brace ('{') introducing the optional
    *         parameters
    */
   Token get leftDelimiter => _leftDelimiter;
@@ skipping 74 matching lines @@
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _parameters.accept(visitor);
   }
 }
 
 /**
  * The abstract class `FunctionBody` defines the behavior common to objects representing the
  * body of a function or method.
  *
  * <pre>
@@ skipping 56 matching lines @@
    * @param propertyKeyword the token representing the 'get' or 'set' keyword
    * @param name the name of the function
    * @param functionExpression the function expression being wrapped
    */
   FunctionDeclaration(Comment comment, List<Annotation> metadata, this.externalKeyword, TypeName returnType, this.propertyKeyword, SimpleIdentifier name, FunctionExpression functionExpression) : super(comment, metadata) {
     this._returnType = becomeParentOf(returnType);
     this._name = becomeParentOf(name);
     this._functionExpression = becomeParentOf(functionExpression);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitFunctionDeclaration(this);
 
+  @override
   ExecutableElement get element => _name != null ? (_name.staticElement as ExecutableElement) : null;
 
+  @override
   Token get endToken => _functionExpression.endToken;
 
   /**
    * Return the function expression being wrapped.
    *
    * @return the function expression being wrapped
    */
   FunctionExpression get functionExpression => _functionExpression;
 
   /**
@@ skipping 44 matching lines @@
 
   /**
    * Set the return type of the function to the given name.
    *
    * @param name the return type of the function
    */
   void set returnType(TypeName name) {
     _returnType = becomeParentOf(name);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_functionExpression, visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata {
     if (externalKeyword != null) {
       return externalKeyword;
     }
     if (_returnType != null) {
       return _returnType.beginToken;
     } else if (propertyKeyword != null) {
       return propertyKeyword;
     } else if (_name != null) {
       return _name.beginToken;
@@ skipping 14 matching lines @@
 
   /**
    * Initialize a newly created function declaration statement.
    *
    * @param functionDeclaration the the function declaration being wrapped
    */
   FunctionDeclarationStatement(FunctionDeclaration functionDeclaration) {
     this._functionDeclaration = becomeParentOf(functionDeclaration);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitFunctionDeclarationStatement(this);
 
+  @override
   Token get beginToken => _functionDeclaration.beginToken;
 
+  @override
   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);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_functionDeclaration, visitor);
   }
 }
 
 /**
  * Instances of the class `FunctionExpression` represent a function expression.
  *
  * <pre>
  * functionExpression ::=
@@ skipping 21 matching lines @@
    * 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._parameters = becomeParentOf(parameters);
     this._body = becomeParentOf(body);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitFunctionExpression(this);
 
+  @override
   Token get beginToken {
     if (_parameters != null) {
       return _parameters.beginToken;
     } else if (_body != null) {
       return _body.beginToken;
     }
     // This should never be reached because external functions must be named, hence either the body
     // or the name should be non-null.
     throw new IllegalStateException("Non-external functions must have a body");
   }
 
   /**
    * Return the body of the function, or `null` if this is an external function.
    *
    * @return the body of the function
    */
   FunctionBody get body => _body;
 
+  @override
   Token get endToken {
     if (_body != null) {
       return _body.endToken;
     } else if (_parameters != null) {
       return _parameters.endToken;
     }
     // This should never be reached because external functions must be named, hence either the body
     // or the name should be non-null.
     throw new IllegalStateException("Non-external functions must have a body");
   }
 
   /**
    * Return the parameters associated with the function.
    *
    * @return the parameters associated with the function
    */
   FormalParameterList get parameters => _parameters;
 
+  @override
   int get precedence => 16;
 
   /**
    * Set the body of the function to the given function body.
    *
    * @param functionBody the body of the function
    */
   void set body(FunctionBody functionBody) {
     _body = becomeParentOf(functionBody);
   }
 
   /**
    * Set the parameters associated with the function to the given list of parameters.
    *
    * @param parameters the parameters associated with the function
    */
   void set parameters(FormalParameterList parameters) {
     this._parameters = becomeParentOf(parameters);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_parameters, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * Instances of the class `FunctionExpressionInvocation` represent the invocation of a
  * function resulting from evaluating an expression. Invocations of methods and other forms of
  * functions are represented by [MethodInvocation] nodes. Invocations of
@@ skipping 32 matching lines @@
    * 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._function = becomeParentOf(function);
     this._argumentList = becomeParentOf(argumentList);
   }
 
+  @override
   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;
 
+  @override
   Token get beginToken => _function.beginToken;
 
   /**
    * Return the best element available for the function being invoked. If resolution was able to
    * find a better element based on type propagation, that element will be returned. Otherwise, the
    * element found using the result of static analysis will be returned. If resolution has not been
    * performed, then `null` will be returned.
    *
    * @return the best element available for this function
    */
   ExecutableElement get bestElement {
     ExecutableElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
+  @override
   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;
 
+  @override
   int get precedence => 15;
 
   /**
    * Return the element associated with the function being invoked based on propagated type
    * information, or `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
    */
@@ skipping 20 matching lines @@
   /**
    * Set the element associated with the function being invoked based on propagated type information
    * to the given element.
    *
    * @param element the element to be associated with the function being invoked
    */
   void set propagatedElement(ExecutableElement element) {
     _propagatedElement = element;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_function, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * Instances of the class `FunctionTypeAlias` represent a function type alias.
  *
  * <pre>
@@ skipping 39 matching lines @@
    * @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) {
     this._returnType = becomeParentOf(returnType);
     this._name = becomeParentOf(name);
     this._typeParameters = becomeParentOf(typeParameters);
     this._parameters = becomeParentOf(parameters);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitFunctionTypeAlias(this);
 
+  @override
   FunctionTypeAliasElement get element => _name != null ? (_name.staticElement as FunctionTypeAliasElement) : null;
 
   /**
    * Return the name of the function type being declared.
    *
    * @return the name of the function type being declared
    */
   SimpleIdentifier get name => _name;
 
   /**
@@ skipping 48 matching lines @@
 
   /**
    * 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 typeParameters(TypeParameterList typeParameters) {
     this._typeParameters = becomeParentOf(typeParameters);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
@@ skipping 24 matching lines @@
    * @param returnType the return type of the function, or `null` if the function does not
    *          have a return type
    * @param identifier the name of the function-typed parameter
    * @param parameters the parameters of the function-typed parameter
    */
   FunctionTypedFormalParameter(Comment comment, List<Annotation> metadata, TypeName returnType, SimpleIdentifier identifier, FormalParameterList parameters) : super(comment, metadata, identifier) {
     this._returnType = becomeParentOf(returnType);
     this._parameters = becomeParentOf(parameters);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitFunctionTypedFormalParameter(this);
 
+  @override
   Token get beginToken {
     if (_returnType != null) {
       return _returnType.beginToken;
     }
     return identifier.beginToken;
   }
 
+  @override
   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 `null` if the function does not have a return
    * type.
    *
    * @return the return type of the function
    */
   TypeName get returnType => _returnType;
 
+  @override
   bool get isConst => false;
 
+  @override
   bool get 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 parameters(FormalParameterList parameters) {
     this._parameters = becomeParentOf(parameters);
   }
 
   /**
    * Set the return type of the function to the given type.
    *
    * @param returnType the return type of the function
    */
   void set returnType(TypeName returnType) {
     this._returnType = becomeParentOf(returnType);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(identifier, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 
 /**
  * Instances of the class `HideCombinator` represent a combinator that restricts the names
@@ skipping 14 matching lines @@
    * 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) {
     this._hiddenNames = new NodeList<SimpleIdentifier>(this);
     this._hiddenNames.addAll(hiddenNames);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitHideCombinator(this);
 
+  @override
   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;
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _hiddenNames.accept(visitor);
   }
 }
 
 /**
  * The abstract class `Identifier` defines the behavior common to nodes that represent an
  * identifier.
  *
  * <pre>
@@ skipping 42 matching lines @@
   /**
    * Return the element associated with this identifier based on static type information, or
    * `null` if the AST structure has not been resolved or if this identifier could not be
    * resolved. One example of the latter case is an identifier that is not defined within the scope
    * in which it appears
    *
    * @return the element associated with the operator
    */
   Element get staticElement;
 
+  @override
   bool get isAssignable => true;
 }
 
 /**
  * Instances of the class `IfStatement` represent an if statement.
  *
  * <pre>
  * ifStatement ::=
  *     'if' '(' [Expression] ')' [Statement] ('else' [Statement])?
  * </pre>
@@ skipping 45 matching lines @@
    * @param thenStatement the statement that is executed if the condition evaluates to `true`
    * @param elseKeyword the token representing the 'else' keyword
    * @param elseStatement the statement that is executed if the condition evaluates to `false`
    */
   IfStatement(this.ifKeyword, this.leftParenthesis, Expression condition, this.rightParenthesis, Statement thenStatement, this.elseKeyword, Statement elseStatement) {
     this._condition = becomeParentOf(condition);
     this._thenStatement = becomeParentOf(thenStatement);
     this._elseStatement = becomeParentOf(elseStatement);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitIfStatement(this);
 
+  @override
   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 statement that is executed if the condition evaluates to `false`, or
    * `null` if there is no else statement.
    *
    * @return the statement that is executed if the condition evaluates to `false`
    */
   Statement get elseStatement => _elseStatement;
 
+  @override
   Token get endToken {
     if (_elseStatement != null) {
       return _elseStatement.endToken;
     }
     return _thenStatement.endToken;
   }
 
   /**
    * Return the statement that is executed if the condition evaluates to `true`.
    *
@@ skipping 24 matching lines @@
   /**
    * Set the statement that is executed if the condition evaluates to `true` to the given
    * statement.
    *
    * @param statement the statement that is executed if the condition evaluates to `true`
    */
   void set thenStatement(Statement statement) {
     _thenStatement = becomeParentOf(statement);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_thenStatement, visitor);
     safelyVisitChild(_elseStatement, visitor);
   }
 }
 
 /**
  * Instances of the class `ImplementsClause` represent the "implements" clause in an class
  * declaration.
@@ skipping 18 matching lines @@
    * Initialize a newly created implements clause.
    *
    * @param keyword the token representing the 'implements' keyword
    * @param interfaces the interfaces that are being implemented
    */
   ImplementsClause(this.keyword, List<TypeName> interfaces) {
     this._interfaces = new NodeList<TypeName>(this);
     this._interfaces.addAll(interfaces);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitImplementsClause(this);
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   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;
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _interfaces.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `ImportDirective` represent an import directive.
  *
  * <pre>
  * importDirective ::=
@@ skipping 112 matching lines @@
    * @param libraryUri the URI of the library being imported
    * @param asToken the token representing the 'as' token
    * @param prefix the prefix to be used with the imported names
    * @param combinators the combinators used to control how names are imported
    * @param semicolon the semicolon terminating the directive
    */
   ImportDirective(Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, this.asToken, SimpleIdentifier prefix, List<Combinator> combinators, Token semicolon) : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
     this._prefix = becomeParentOf(prefix);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitImportDirective(this);
 
+  @override
   ImportElement get element => super.element as ImportElement;
 
   /**
    * Return the prefix to be used with the imported names, or `null` if the imported names are
    * not prefixed.
    *
    * @return the prefix to be used with the imported names
    */
   SimpleIdentifier get prefix => _prefix;
 
+  @override
   LibraryElement get uriElement {
     ImportElement element = this.element;
     if (element == null) {
       return null;
     }
     return element.importedLibrary;
   }
 
   /**
    * 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 prefix(SimpleIdentifier prefix) {
     this._prefix = becomeParentOf(prefix);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
     combinators.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `IndexExpression` represent an index expression.
  *
@@ skipping 73 matching lines @@
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
   IndexExpression.forCascade(this.period, Token leftBracket, Expression index, Token rightBracket) {
     this._leftBracket = leftBracket;
     this._index = becomeParentOf(index);
     this._rightBracket = rightBracket;
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitIndexExpression(this);
 
+  @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return period;
   }
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
    * @return the best element available for this operator
    */
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
+  @override
   Token get endToken => _rightBracket;
 
   /**
    * Return the expression used to compute the index.
    *
    * @return the expression used to compute the index
    */
   Expression get index => _index;
 
   /**
    * Return the left square bracket.
    *
    * @return the left square bracket
    */
   Token get leftBracket => _leftBracket;
 
+  @override
   int get precedence => 15;
 
   /**
    * Return the element associated with the operator based on the propagated type of the target, or
    * `null` if the AST structure has not been resolved 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
    * target.
    *
    * @return the element associated with this operator
    */
@@ skipping 83 matching lines @@
     if (parent is PrefixExpression) {
       return parent.operator.type.isIncrementOperator;
     } else if (parent is PostfixExpression) {
       return true;
     } else if (parent is AssignmentExpression) {
       return identical(parent.leftHandSide, this);
     }
     return false;
   }
 
+  @override
   bool get isAssignable => true;
 
   /**
    * Return `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
    * [CascadeExpression].
    *
    * @return `true` if this expression is cascaded
    */
   bool get isCascaded => period != null;
@@ skipping 47 matching lines @@
 
   /**
    * 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 target(Expression expression) {
     _target = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_index, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the index expression will be bound. Otherwise, return `null`.
    *
@@ skipping 71 matching lines @@
    *
    * @param keyword the keyword used to indicate how an object should be created
    * @param constructorName the name of the constructor to be invoked
    * @param argumentList the list of arguments to the constructor
    */
   InstanceCreationExpression(this.keyword, ConstructorName constructorName, ArgumentList argumentList) {
     this.constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
+  @override
   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;
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   Token get endToken => _argumentList.endToken;
 
+  @override
   int get precedence => 15;
 
   /**
    * Return `true` if this creation expression is used to invoke a constant constructor.
    *
    * @return `true` if this creation expression is used to invoke a constant constructor
    */
   bool get isConst => keyword is KeywordToken && identical((keyword as KeywordToken).keyword, Keyword.CONST);
 
   /**
    * Set the list of arguments to the constructor to the given list.
    *
    * @param argumentList the list of arguments to the constructor
    */
   void set argumentList(ArgumentList argumentList) {
     this._argumentList = becomeParentOf(argumentList);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * Instances of the class `IntegerLiteral` represent an integer literal expression.
  *
  * <pre>
@@ skipping 21 matching lines @@
   int value = 0;
 
   /**
    * Initialize a newly created integer literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   IntegerLiteral(this.literal, this.value);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitIntegerLiteral(this);
 
+  @override
   Token get beginToken => literal;
 
+  @override
   Token get endToken => literal;
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * The abstract class `InterpolationElement` defines the behavior common to elements within a
  * [StringInterpolation].
  *
  * <pre>
  * interpolationElement ::=
@@ skipping 35 matching lines @@
    * Initialize a newly created interpolation expression.
    *
    * @param leftBracket the left curly bracket
    * @param expression the expression to be evaluated for the value to be converted into a string
    * @param rightBracket the right curly bracket
    */
   InterpolationExpression(this.leftBracket, Expression expression, this.rightBracket) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitInterpolationExpression(this);
 
+  @override
   Token get beginToken => leftBracket;
 
+  @override
   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;
 
   /**
    * 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 expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `InterpolationString` represent a non-empty substring of an
  * interpolated string.
  *
  * <pre>
@@ skipping 16 matching lines @@
    * 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._contents = contents;
     this._value = value;
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitInterpolationString(this);
 
+  @override
   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;
 
+  @override
   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 contents(Token string) {
     _contents = string;
   }
 
   /**
    * Set the value of the literal to the given string.
    *
    * @param string the value of the literal
    */
   void set value(String string) {
     _value = string;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `IsExpression` represent an is expression.
  *
  * <pre>
  * isExpression ::=
  *     [Expression] 'is' '!'? [TypeName]
@@ skipping 26 matching lines @@
    * @param expression the expression used to compute the value whose type is being tested
    * @param isOperator the is operator
    * @param notOperator the not operator, or `null` if the sense of the test is not negated
    * @param type the name of the type being tested for
    */
   IsExpression(Expression expression, this.isOperator, this.notOperator, TypeName type) {
     this._expression = becomeParentOf(expression);
     this._type = becomeParentOf(type);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitIsExpression(this);
 
+  @override
   Token get beginToken => _expression.beginToken;
 
+  @override
   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;
 
+  @override
   int get precedence => 7;
 
   /**
    * 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 expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
   /**
    * 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 type(TypeName name) {
     this._type = becomeParentOf(name);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 
 /**
  * Instances of the class `Label` represent a label.
  *
  * <pre>
@@ skipping 15 matching lines @@
   /**
    * Initialize a newly created label.
    *
    * @param label the label being applied
    * @param colon the colon that separates the label from whatever follows
    */
   Label(SimpleIdentifier label, this.colon) {
     this._label = becomeParentOf(label);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitLabel(this);
 
+  @override
   Token get beginToken => _label.beginToken;
 
+  @override
   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 label being associated with the statement to the given label.
    *
    * @param label the label being associated with the statement
    */
   void set label(SimpleIdentifier label) {
     this._label = becomeParentOf(label);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 
 /**
  * Instances of the class `LabeledStatement` represent a statement that has a label associated
  * with them.
  *
  * <pre>
@@ skipping 17 matching lines @@
    *
    * @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._labels = new NodeList<Label>(this);
     this._labels.addAll(labels);
     this._statement = becomeParentOf(statement);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitLabeledStatement(this);
 
+  @override
   Token get beginToken {
     if (!_labels.isEmpty) {
       return _labels.beginToken;
     }
     return _statement.beginToken;
   }
 
+  @override
   Token get endToken => _statement.endToken;
 
   /**
    * Return the labels being associated with the statement.
    *
    * @return the labels being associated with the statement
    */
   NodeList<Label> get labels => _labels;
 
   /**
    * Return the statement with which the labels are being associated.
    *
    * @return the statement with which the labels are being associated
    */
   Statement get statement => _statement;
 
   /**
    * Set the statement with which the labels are being associated to the given statement.
    *
    * @param statement the statement with which the labels are being associated
    */
   void set statement(Statement statement) {
     this._statement = becomeParentOf(statement);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _labels.accept(visitor);
     safelyVisitChild(_statement, visitor);
   }
 }
 
 /**
  * Instances of the class `LibraryDirective` represent a library directive.
  *
  * <pre>
@@ skipping 23 matching lines @@
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param libraryToken the token representing the 'library' token
    * @param name the name of the library being defined
    * @param semicolon the semicolon terminating the directive
    */
   LibraryDirective(Comment comment, List<Annotation> metadata, this.libraryToken, LibraryIdentifier name, this.semicolon) : super(comment, metadata) {
     this._name = becomeParentOf(name);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitLibraryDirective(this);
 
+  @override
   Token get endToken => semicolon;
 
+  @override
   Token get keyword => libraryToken;
 
   /**
    * Return the name of the library being defined.
    *
    * @return the name of the library being defined
    */
   LibraryIdentifier get name => _name;
 
   /**
    * 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 name) {
     this._name = becomeParentOf(name);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata => libraryToken;
 }
 
 /**
  * Instances of the class `LibraryIdentifier` represent the identifier for a library.
  *
  * <pre>
  * libraryIdentifier ::=
  *     [SimpleIdentifier] ('.' [SimpleIdentifier])*
  * </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) {
     this._components = new NodeList<SimpleIdentifier>(this);
     this._components.addAll(components);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitLibraryIdentifier(this);
 
+  @override
   Token get beginToken => _components.beginToken;
 
+  @override
   Element get bestElement => staticElement;
 
   /**
    * Return the components of the identifier.
    *
    * @return the components of the identifier
    */
   NodeList<SimpleIdentifier> get components => _components;
 
+  @override
   Token get endToken => _components.endToken;
 
+  @override
   String get name {
     JavaStringBuilder builder = new JavaStringBuilder();
     bool needsPeriod = false;
     for (SimpleIdentifier identifier in _components) {
       if (needsPeriod) {
         builder.append(".");
       } else {
         needsPeriod = true;
       }
       builder.append(identifier.name);
     }
     return builder.toString();
   }
 
+  @override
   int get precedence => 15;
 
+  @override
   Element get propagatedElement => null;
 
+  @override
   Element get staticElement => null;
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _components.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `ListLiteral` represent a list literal.
  *
  * <pre>
  * listLiteral ::=
@@ skipping 26 matching lines @@
    * @param elements the expressions used to compute the elements of the list
    * @param rightBracket the right square bracket
    */
   ListLiteral(Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<Expression> elements, Token rightBracket) : super(constKeyword, typeArguments) {
     this._elements = new NodeList<Expression>(this);
     this._leftBracket = leftBracket;
     this._elements.addAll(elements);
     this._rightBracket = rightBracket;
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitListLiteral(this);
 
+  @override
   Token get beginToken {
     Token token = constKeyword;
     if (token != null) {
       return token;
     }
     TypeArgumentList typeArguments = this.typeArguments;
     if (typeArguments != null) {
       return typeArguments.beginToken;
     }
     return _leftBracket;
   }
 
   /**
    * Return the expressions used to compute the elements of the list.
    *
    * @return the expressions used to compute the elements of the list
    */
   NodeList<Expression> get elements => _elements;
 
+  @override
   Token get endToken => _rightBracket;
 
   /**
    * Return the left square bracket.
    *
    * @return the left square bracket
    */
   Token get leftBracket => _leftBracket;
 
   /**
@@ skipping 14 matching lines @@
 
   /**
    * Set the right square bracket to the given token.
    *
    * @param bracket the right square bracket
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _elements.accept(visitor);
   }
 }
 
 /**
  * The abstract class `Literal` defines the behavior common to nodes that represent a literal
  * expression.
  *
  * <pre>
  * literal ::=
  *     [BooleanLiteral]
  *   | [DoubleLiteral]
  *   | [IntegerLiteral]
  *   | [ListLiteral]
  *   | [MapLiteral]
  *   | [NullLiteral]
  *   | [StringLiteral]
  * </pre>
  */
 abstract class Literal extends Expression {
+  @override
   int get precedence => 16;
 }
 
 /**
  * Instances of the class `MapLiteral` represent a literal map.
  *
  * <pre>
  * mapLiteral ::=
  *     'const'? ('<' [TypeName] (',' [TypeName])* '>')? '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
  * </pre>
@@ skipping 24 matching lines @@
    * @param entries the entries in the map
    * @param rightBracket the right curly bracket
    */
   MapLiteral(Token constKeyword, TypeArgumentList typeArguments, Token leftBracket, List<MapLiteralEntry> entries, Token rightBracket) : super(constKeyword, typeArguments) {
     this._entries = new NodeList<MapLiteralEntry>(this);
     this._leftBracket = leftBracket;
     this._entries.addAll(entries);
     this._rightBracket = rightBracket;
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitMapLiteral(this);
 
+  @override
   Token get beginToken {
     Token token = constKeyword;
     if (token != null) {
       return token;
     }
     TypeArgumentList typeArguments = this.typeArguments;
     if (typeArguments != null) {
       return typeArguments.beginToken;
     }
     return _leftBracket;
   }
 
+  @override
   Token get endToken => _rightBracket;
 
   /**
    * Return the entries in the map.
    *
    * @return the entries in the map
    */
   NodeList<MapLiteralEntry> get entries => _entries;
 
   /**
@@ skipping 21 matching lines @@
 
   /**
    * Set the right curly bracket to the given token.
    *
    * @param bracket the right curly bracket
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _entries.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `MapLiteralEntry` represent a single key/value pair in a map
  * literal.
  *
@@ skipping 23 matching lines @@
    *
    * @param key the expression computing the key with which the value will be associated
    * @param separator the colon that separates the key from the value
    * @param value the expression computing the value that will be associated with the key
    */
   MapLiteralEntry(Expression key, this.separator, Expression value) {
     this._key = becomeParentOf(key);
     this._value = becomeParentOf(value);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitMapLiteralEntry(this);
 
+  @override
   Token get beginToken => _key.beginToken;
 
+  @override
   Token get endToken => _value.endToken;
 
   /**
    * Return the expression computing the key with which the value will be associated.
    *
    * @return the expression computing the key with which the value will be associated
    */
   Expression get key => _key;
 
   /**
@@ skipping 16 matching lines @@
   /**
    * 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 value(Expression expression) {
     _value = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_key, visitor);
     safelyVisitChild(_value, visitor);
   }
 }
 
 /**
  * Instances of the class `MethodDeclaration` represent a method declaration.
  *
  * <pre>
@@ skipping 68 matching lines @@
    *          declares a getter
    * @param body the body of the method
    */
   MethodDeclaration(Comment comment, List<Annotation> metadata, this.externalKeyword, this.modifierKeyword, TypeName returnType, this.propertyKeyword, this.operatorKeyword, SimpleIdentifier name, FormalParameterList parameters, FunctionBody body) : super(comment, metadata) {
     this._returnType = becomeParentOf(returnType);
     this._name = becomeParentOf(name);
     this._parameters = becomeParentOf(parameters);
     this._body = becomeParentOf(body);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitMethodDeclaration(this);
 
   /**
    * Return the body of the method.
    *
    * @return the body of the method
    */
   FunctionBody get body => _body;
 
   /**
    * Return the element associated with this method, or `null` if the AST structure has not
    * been resolved. The element can either be a [MethodElement], if this represents the
    * declaration of a normal method, or a [PropertyAccessorElement] if this represents the
    * declaration of either a getter or a setter.
    *
    * @return the element associated with this method
    */
+  @override
   ExecutableElement get element => _name != null ? (_name.staticElement as ExecutableElement) : null;
 
+  @override
   Token get endToken => _body.endToken;
 
   /**
    * Return the name of the method.
    *
    * @return the name of the method
    */
   SimpleIdentifier get name => _name;
 
   /**
@@ skipping 75 matching lines @@
 
   /**
    * Set the return type of the method to the given type name.
    *
    * @param typeName the return type of the method
    */
   void set returnType(TypeName typeName) {
     _returnType = becomeParentOf(typeName);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_parameters, visitor);
     safelyVisitChild(_body, visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata {
     if (modifierKeyword != null) {
       return modifierKeyword;
     } else if (_returnType != null) {
       return _returnType.beginToken;
     } else if (propertyKeyword != null) {
       return propertyKeyword;
     } else if (operatorKeyword != null) {
       return operatorKeyword;
     }
@@ skipping 43 matching lines @@
    * @param period the period that separates the target from the method name
    * @param methodName the name of the method being invoked
    * @param argumentList the list of arguments to the method
    */
   MethodInvocation(Expression target, this.period, SimpleIdentifier methodName, ArgumentList argumentList) {
     this._target = becomeParentOf(target);
     this._methodName = becomeParentOf(methodName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
+  @override
   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;
 
+  @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     } else if (period != null) {
       return period;
     }
     return _methodName.beginToken;
   }
 
+  @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * Return the name of the method being invoked.
    *
    * @return the name of the method being invoked
    */
   SimpleIdentifier get methodName => _methodName;
 
+  @override
   int get precedence => 15;
 
   /**
    * Return the expression used to compute the receiver of the invocation. If this invocation is not
    * part of a cascade expression, then this is the same as [getTarget]. If this invocation
    * is part of a cascade expression, then the target stored with the cascade expression is
    * returned.
    *
    * @return the expression used to compute the receiver of the invocation
    * @see #getTarget()
@@ skipping 51 matching lines @@
 
   /**
    * 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 target(Expression expression) {
     _target = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_methodName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * Instances of the class `NamedExpression` represent an expression that has a name associated
  * with it. They are used in method invocations when there are named parameters.
@@ skipping 18 matching lines @@
    * 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._name = becomeParentOf(name);
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitNamedExpression(this);
 
+  @override
   Token get beginToken => _name.beginToken;
 
   /**
    * Return the element representing the parameter being named by this expression, or `null`
    * if the AST structure has not been resolved or if there is no parameter with the same name as
    * this expression.
    *
    * @return the element representing the parameter being named by this expression
    */
   ParameterElement get element {
     Element element = _name.label.staticElement;
     if (element is ParameterElement) {
       return element;
     }
     return null;
   }
 
+  @override
   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;
 
+  @override
   int get precedence => 0;
 
   /**
    * 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 expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
   /**
    * Set the name associated with the expression to the given identifier.
    *
    * @param identifier the name associated with the expression
    */
   void set name(Label identifier) {
     _name = becomeParentOf(identifier);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * The abstract class `NamespaceDirective` defines the behavior common to nodes that represent
  * a directive that impacts the namespace of a library.
  *
@@ skipping 34 matching lines @@
     this._combinators.addAll(combinators);
   }
 
   /**
    * Return the combinators used to control how names are imported or exported.
    *
    * @return the combinators used to control how names are imported or exported
    */
   NodeList<Combinator> get combinators => _combinators;
 
+  @override
   Token get endToken => semicolon;
 
+  @override
   LibraryElement get uriElement;
 
+  @override
   Token get firstTokenAfterCommentAndMetadata => keyword;
 }
 
 /**
  * Instances of the class `NativeClause` represent the "native" clause in an class
  * declaration.
  *
  * <pre>
  * nativeClause ::=
  *     'native' [StringLiteral]
@@ skipping 11 matching lines @@
   StringLiteral name;
 
   /**
    * Initialize a newly created native clause.
    *
    * @param keyword the token representing the 'native' keyword
    * @param name the name of the native object that implements the class.
    */
   NativeClause(this.keyword, this.name);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitNativeClause(this);
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   Token get endToken => name.endToken;
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(name, visitor);
   }
 }
 
 /**
  * Instances of the class `NativeFunctionBody` represent a function body that consists of a
  * native keyword followed by a string literal.
  *
  * <pre>
@@ skipping 22 matching lines @@
    * and a semicolon.
    *
    * @param nativeToken the token representing 'native' that marks the start of the function body
    * @param stringLiteral the string literal
    * @param semicolon the token representing the semicolon that marks the end of the function body
    */
   NativeFunctionBody(this.nativeToken, StringLiteral stringLiteral, this.semicolon) {
     this._stringLiteral = becomeParentOf(stringLiteral);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitNativeFunctionBody(this);
 
+  @override
   Token get beginToken => nativeToken;
 
+  @override
   Token get endToken => semicolon;
 
   /**
    * Return the string literal representing the string after the 'native' token.
    *
    * @return the string literal representing the string after the 'native' token
    */
   StringLiteral get stringLiteral => _stringLiteral;
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_stringLiteral, visitor);
   }
 }
 
 /**
  * The abstract class `NormalFormalParameter` defines the behavior common to formal parameters
  * that are required (are not optional).
  *
  * <pre>
@@ skipping 35 matching lines @@
   }
 
   /**
    * Return the documentation comment associated with this parameter, or `null` if this
    * parameter does not have a documentation comment associated with it.
    *
    * @return the documentation comment associated with this parameter
    */
   Comment get documentationComment => _comment;
 
+  @override
   SimpleIdentifier get identifier => _identifier;
 
+  @override
   ParameterKind get kind {
     AstNode parent = this.parent;
     if (parent is DefaultFormalParameter) {
       return parent.kind;
     }
     return ParameterKind.REQUIRED;
   }
 
   /**
    * Return the annotations associated with this parameter.
@@ skipping 13 matching lines @@
 
   /**
    * Set the name of the parameter being declared to the given identifier.
    *
    * @param identifier the name of the parameter being declared
    */
   void set identifier(SimpleIdentifier identifier) {
     this._identifier = becomeParentOf(identifier);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     //
     // Note that subclasses are responsible for visiting the identifier because they often need to
     // visit other nodes before visiting the identifier.
     //
     if (_commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (AstNode child in sortedCommentAndAnnotations) {
@@ skipping 48 matching lines @@
 
   /**
    * Initialize a newly created null literal.
    *
    * @param token the token representing the literal
    */
   NullLiteral(Token token) {
     this.literal = token;
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitNullLiteral(this);
 
+  @override
   Token get beginToken => literal;
 
+  @override
   Token get endToken => literal;
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `ParenthesizedExpression` represent a parenthesized expression.
  *
  * <pre>
  * parenthesizedExpression ::=
  *     '(' [Expression] ')'
@@ skipping 21 matching lines @@
    * @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._leftParenthesis = leftParenthesis;
     this._expression = becomeParentOf(expression);
     this._rightParenthesis = rightParenthesis;
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitParenthesizedExpression(this);
 
+  @override
   Token get beginToken => _leftParenthesis;
 
+  @override
   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;
 
+  @override
   int get precedence => 15;
 
   /**
    * Return the right parenthesis.
    *
    * @return the right parenthesis
    */
   Token get rightParenthesis => _rightParenthesis;
 
   /**
@@ skipping 16 matching lines @@
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `PartDirective` represent a part directive.
  *
  * <pre>
  * partDirective ::=
@@ skipping 15 matching lines @@
    * Initialize a newly created part directive.
    *
    * @param comment the documentation comment associated with this directive
    * @param metadata the annotations associated with the directive
    * @param partToken the token representing the 'part' token
    * @param partUri the URI of the part being included
    * @param semicolon the semicolon terminating the directive
    */
   PartDirective(Comment comment, List<Annotation> metadata, this.partToken, StringLiteral partUri, this.semicolon) : super(comment, metadata, partUri);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitPartDirective(this);
 
+  @override
   Token get endToken => semicolon;
 
+  @override
   Token get keyword => partToken;
 
+  @override
   CompilationUnitElement get uriElement => element as CompilationUnitElement;
 
+  @override
   Token get firstTokenAfterCommentAndMetadata => partToken;
 }
 
 /**
  * Instances of the class `PartOfDirective` represent a part-of directive.
  *
  * <pre>
  * partOfDirective ::=
  *     [Annotation] 'part' 'of' [Identifier] ';'
  * </pre>
@@ skipping 26 matching lines @@
    * @param metadata the annotations associated with the directive
    * @param partToken the token representing the 'part' token
    * @param ofToken the token representing the 'of' token
    * @param libraryName the name of the library that the containing compilation unit is part of
    * @param semicolon the semicolon terminating the directive
    */
   PartOfDirective(Comment comment, List<Annotation> metadata, this.partToken, this.ofToken, LibraryIdentifier libraryName, this.semicolon) : super(comment, metadata) {
     this._libraryName = becomeParentOf(libraryName);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitPartOfDirective(this);
 
+  @override
   Token get endToken => semicolon;
 
+  @override
   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;
 
   /**
    * 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 libraryName(LibraryIdentifier libraryName) {
     this._libraryName = becomeParentOf(libraryName);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_libraryName, visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata => partToken;
 }
 
 /**
  * Instances of the class `PostfixExpression` represent a postfix unary expression.
  *
  * <pre>
  * postfixExpression ::=
  *     [Expression] [Token]
  * </pre>
@@ skipping 26 matching lines @@
   /**
    * Initialize a newly created postfix expression.
    *
    * @param operand the expression computing the operand for the operator
    * @param operator the postfix operator being applied to the operand
    */
   PostfixExpression(Expression operand, this.operator) {
     this._operand = becomeParentOf(operand);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitPostfixExpression(this);
 
+  @override
   Token get beginToken => _operand.beginToken;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
    * @return the best element available for this operator
    */
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
+  @override
   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;
 
+  @override
   int get precedence => 15;
 
   /**
    * Return the element associated with the operator based on the propagated type of the operand, or
    * `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
    */
@@ skipping 31 matching lines @@
   /**
    * Set the element associated with the operator based on the static type of the operand to the
    * given element.
    *
    * @param element the element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_operand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the operand will be bound. Otherwise, return `null`.
    *
    * This method is only intended to be used by [Expression#getPropagatedParameterElement].
@@ skipping 70 matching lines @@
   /**
    * Initialize a newly created prefix expression.
    *
    * @param operator the prefix operator being applied to the operand
    * @param operand the expression computing the operand for the operator
    */
   PrefixExpression(this.operator, Expression operand) {
     this._operand = becomeParentOf(operand);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitPrefixExpression(this);
 
+  @override
   Token get beginToken => operator;
 
   /**
    * Return the best element available for this operator. If resolution was able to find a better
    * element based on type propagation, that element will be returned. Otherwise, the element found
    * using the result of static analysis will be returned. If resolution has not been performed,
    * then `null` will be returned.
    *
    * @return the best element available for this operator
    */
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
+  @override
   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;
 
+  @override
   int get precedence => 14;
 
   /**
    * Return the element associated with the operator based on the propagated type of the operand, or
    * `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
    */
@@ skipping 31 matching lines @@
   /**
    * Set the element associated with the operator based on the static type of the operand to the
    * given element.
    *
    * @param element the static element to be associated with the operator
    */
   void set staticElement(MethodElement element) {
     _staticElement = element;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_operand, visitor);
   }
 
   /**
    * If the AST structure has been resolved, and the function being invoked is known based on
    * propagated type information, then return the parameter element representing the parameter to
    * which the value of the operand will be bound. Otherwise, return `null`.
    *
    * This method is only intended to be used by [Expression#getPropagatedParameterElement].
@@ skipping 65 matching lines @@
    *
    * @param prefix the identifier being prefixed
    * @param period the period used to separate the prefix from the identifier
    * @param identifier the prefix associated with the library in which the identifier is defined
    */
   PrefixedIdentifier(SimpleIdentifier prefix, this.period, SimpleIdentifier identifier) {
     this._prefix = becomeParentOf(prefix);
     this._identifier = becomeParentOf(identifier);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitPrefixedIdentifier(this);
 
+  @override
   Token get beginToken => _prefix.beginToken;
 
+  @override
   Element get bestElement {
     if (_identifier == null) {
       return null;
     }
     return _identifier.bestElement;
   }
 
+  @override
   Token get endToken => _identifier.endToken;
 
   /**
    * Return the identifier being prefixed.
    *
    * @return the identifier being prefixed
    */
   SimpleIdentifier get identifier => _identifier;
 
+  @override
   String get name => "${_prefix.name}.${_identifier.name}";
 
+  @override
   int get precedence => 15;
 
   /**
    * 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;
 
+  @override
   Element get propagatedElement {
     if (_identifier == null) {
       return null;
     }
     return _identifier.propagatedElement;
   }
 
+  @override
   Element get staticElement {
     if (_identifier == null) {
       return null;
     }
     return _identifier.staticElement;
   }
 
   /**
    * Set the identifier being prefixed to the given identifier.
    *
    * @param identifier the identifier being prefixed
    */
   void set identifier(SimpleIdentifier identifier) {
     this._identifier = becomeParentOf(identifier);
   }
 
   /**
    * 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 prefix(SimpleIdentifier identifier) {
     _prefix = becomeParentOf(identifier);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_prefix, visitor);
     safelyVisitChild(_identifier, visitor);
   }
 }
 
 /**
  * Instances of the class `PropertyAccess` represent the access of a property of an object.
  *
  * Note, however, that accesses to properties of objects can also be represented as
@@ skipping 26 matching lines @@
    *
    * @param target the expression computing the object defining the property being accessed
    * @param operator the property access operator
    * @param propertyName the name of the property being accessed
    */
   PropertyAccess(Expression target, this.operator, SimpleIdentifier propertyName) {
     this._target = becomeParentOf(target);
     this._propertyName = becomeParentOf(propertyName);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitPropertyAccess(this);
 
+  @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return operator;
   }
 
+  @override
   Token get endToken => _propertyName.endToken;
 
+  @override
   int get precedence => 15;
 
   /**
    * Return the name of the property being accessed.
    *
    * @return the name of the property being accessed
    */
   SimpleIdentifier get propertyName => _propertyName;
 
   /**
@@ skipping 21 matching lines @@
 
   /**
    * Return the expression computing the object defining the property being accessed, or
    * `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;
 
+  @override
   bool get isAssignable => true;
 
   /**
    * Return `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
    * [CascadeExpression].
    *
    * @return `true` if this expression is cascaded
    */
   bool get isCascaded => operator != null && identical(operator.type, TokenType.PERIOD_PERIOD);
@@ skipping 10 matching lines @@
   /**
    * 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 target(Expression expression) {
     _target = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_target, visitor);
     safelyVisitChild(_propertyName, visitor);
   }
 }
 
 /**
  * Instances of the class `RedirectingConstructorInvocation` represent the invocation of a
  * another constructor in the same class from within a constructor's initialization list.
  *
@@ skipping 38 matching lines @@
    * @param keyword the token for the 'this' keyword
    * @param period the token for the period before the name of the constructor that is being invoked
    * @param constructorName the name of the constructor that is being invoked
    * @param argumentList the list of arguments to the constructor
    */
   RedirectingConstructorInvocation(this.keyword, this.period, SimpleIdentifier constructorName, ArgumentList argumentList) {
     this._constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
+  @override
   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;
 
+  @override
   Token get beginToken => keyword;
 
   /**
    * Return the name of the constructor that is being invoked, or `null` if the unnamed
    * constructor is being invoked.
    *
    * @return the name of the constructor that is being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
 
+  @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * Set the list of arguments to the constructor to the given list.
    *
    * @param argumentList the list of arguments to the constructor
    */
   void set argumentList(ArgumentList argumentList) {
     this._argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * 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 constructorName(SimpleIdentifier identifier) {
     _constructorName = becomeParentOf(identifier);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * Instances of the class `RethrowExpression` represent a rethrow expression.
  *
  * <pre>
  * rethrowExpression ::=
  *     'rethrow'
  * </pre>
  */
 class RethrowExpression extends Expression {
   /**
    * The token representing the 'rethrow' keyword.
    */
   Token keyword;
 
   /**
    * Initialize a newly created rethrow expression.
    *
    * @param keyword the token representing the 'rethrow' keyword
    */
   RethrowExpression(this.keyword);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitRethrowExpression(this);
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   Token get endToken => keyword;
 
+  @override
   int get precedence => 0;
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `ReturnStatement` represent a return statement.
  *
  * <pre>
  * returnStatement ::=
  *     'return' [Expression]? ';'
@@ skipping 20 matching lines @@
    * Initialize a newly created return statement.
    *
    * @param keyword the token representing the 'return' keyword
    * @param expression the expression computing the value to be returned
    * @param semicolon the semicolon terminating the statement
    */
   ReturnStatement(this.keyword, Expression expression, this.semicolon) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitReturnStatement(this);
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   Token get endToken => semicolon;
 
   /**
    * Return the expression computing the value to be returned, or `null` if no explicit value
    * was provided.
    *
    * @return the expression computing the value to be returned
    */
   Expression get expression => _expression;
 
   /**
    * 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 expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `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(this.scriptTag);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitScriptTag(this);
 
+  @override
   Token get beginToken => scriptTag;
 
+  @override
   Token get endToken => scriptTag;
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `ShowCombinator` represent a combinator that restricts the names
  * being imported to those in a given list.
  *
  * <pre>
  * showCombinator ::=
@@ skipping 10 matching lines @@
    * 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) {
     this._shownNames = new NodeList<SimpleIdentifier>(this);
     this._shownNames.addAll(shownNames);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitShowCombinator(this);
 
+  @override
   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;
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _shownNames.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `SimpleFormalParameter` represent a simple formal parameter.
  *
  * <pre>
  * simpleFormalParameter ::=
@@ skipping 19 matching lines @@
    * @param comment the documentation comment associated with this parameter
    * @param metadata the annotations associated with this parameter
    * @param keyword the token representing either the 'final', 'const' or 'var' keyword
    * @param type the name of the declared type of the parameter
    * @param identifier the name of the parameter being declared
    */
   SimpleFormalParameter(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, SimpleIdentifier identifier) : super(comment, metadata, identifier) {
     this._type = becomeParentOf(type);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitSimpleFormalParameter(this);
 
+  @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return identifier.beginToken;
   }
 
+  @override
   Token get endToken => identifier.endToken;
 
   /**
    * Return the name of the declared type of the parameter, or `null` if the parameter does
    * not have a declared type.
    *
    * @return the name of the declared type of the parameter
    */
   TypeName get type => _type;
 
+  @override
   bool get isConst => (keyword is KeywordToken) && identical((keyword as KeywordToken).keyword, Keyword.CONST);
 
+  @override
   bool get isFinal => (keyword is KeywordToken) && identical((keyword as KeywordToken).keyword, Keyword.FINAL);
 
   /**
    * 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 type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
   }
 }
 
 /**
  * Instances of the class `SimpleIdentifier` represent a simple identifier.
  *
@@ skipping 32 matching lines @@
    */
   AuxiliaryElements auxiliaryElements = null;
 
   /**
    * Initialize a newly created identifier.
    *
    * @param token the token representing the identifier
    */
   SimpleIdentifier(this.token);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitSimpleIdentifier(this);
 
+  @override
   Token get beginToken => token;
 
+  @override
   Element get bestElement {
     if (_propagatedElement == null) {
       return _staticElement;
     }
     return _propagatedElement;
   }
 
+  @override
   Token get endToken => token;
 
+  @override
   String get name => token.lexeme;
 
+  @override
   int get precedence => 16;
 
+  @override
   Element get propagatedElement => _propagatedElement;
 
+  @override
   Element get staticElement => _staticElement;
 
   /**
    * Return `true` if this identifier is the name being declared in a declaration.
    *
    * @return `true` if this identifier is the name being declared in a declaration
    */
   bool inDeclarationContext() {
     AstNode parent = this.parent;
     if (parent is CatchClause) {
@@ skipping 100 matching lines @@
     if (parent is PrefixExpression) {
       return (parent as PrefixExpression).operator.type.isIncrementOperator;
     } else if (parent is PostfixExpression) {
       return true;
     } else if (parent is AssignmentExpression) {
       return identical((parent as AssignmentExpression).leftHandSide, target);
     }
     return false;
   }
 
+  @override
   bool get isSynthetic => token.isSynthetic;
 
   /**
    * Set the element associated with this identifier based on propagated type information to the
    * given element.
    *
    * @param element the element to be associated with this identifier
    */
   void set propagatedElement(Element element) {
     _propagatedElement = _validateElement(element);
   }
 
   /**
    * Set the element associated with this identifier based on static type information to the given
    * element.
    *
    * @param element the element to be associated with this identifier
    */
   void set staticElement(Element element) {
     _staticElement = _validateElement(element);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 
   /**
    * Return the given element if it is valid, or report the problem and return `null` if it is
    * not appropriate.
    *
    * @param parent the parent of the element, used for reporting when there is a problem
    * @param isValid `true` if the element is appropriate
    * @param element the element to be associated with this identifier
@@ skipping 86 matching lines @@
   /**
    * Initialize a newly created simple string literal.
    *
    * @param literal the token representing the literal
    * @param value the value of the literal
    */
   SimpleStringLiteral(this.literal, String value) {
     this._value = StringUtilities.intern(value);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitSimpleStringLiteral(this);
 
+  @override
   Token get beginToken => literal;
 
+  @override
   Token get endToken => literal;
 
   /**
    * Return the toolkit specific, non-Dart, element associated with this literal, or `null`.
    *
    * @return the element associated with this literal
    */
   Element get toolkitElement => _toolkitElement;
 
   /**
@@ skipping 34 matching lines @@
     return StringUtilities.endsWith3(lexeme, 0x22, 0x22, 0x22) || StringUtilities.endsWith3(lexeme, 0x27, 0x27, 0x27);
   }
 
   /**
    * Return `true` if this string literal is a raw string.
    *
    * @return `true` if this string literal is a raw string
    */
   bool get isRaw => literal.lexeme.codeUnitAt(0) == 0x72;
 
+  @override
   bool get isSynthetic => literal.isSynthetic;
 
   /**
    * Set the toolkit specific, non-Dart, element associated with this literal.
    *
    * @param element the toolkit specific element to be associated with this literal
    */
   void set toolkitElement(Element element) {
     _toolkitElement = element;
   }
 
   /**
    * Set the value of the literal to the given string.
    *
    * @param string the value of the literal
    */
   void set value(String string) {
     _value = StringUtilities.intern(_value);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 
+  @override
   void appendStringValue(JavaStringBuilder builder) {
     builder.append(value);
   }
 }
 
 /**
  * Instances of the class `Statement` defines the behavior common to nodes that represent a
  * statement.
  *
  * <pre>
@@ skipping 35 matching lines @@
   /**
    * 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._elements = new NodeList<InterpolationElement>(this);
     this._elements.addAll(elements);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitStringInterpolation(this);
 
+  @override
   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;
 
+  @override
   Token get endToken => _elements.endToken;
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _elements.accept(visitor);
   }
 
+  @override
   void appendStringValue(JavaStringBuilder builder) {
     throw new IllegalArgumentException();
   }
 }
 
 /**
  * Instances of the class `StringLiteral` represent a string literal expression.
  *
  * <pre>
  * stringLiteral ::=
@@ skipping 74 matching lines @@
    * @param keyword the token for the 'super' keyword
    * @param period the token for the period before the name of the constructor that is being invoked
    * @param constructorName the name of the constructor that is being invoked
    * @param argumentList the list of arguments to the constructor
    */
   SuperConstructorInvocation(this.keyword, this.period, SimpleIdentifier constructorName, ArgumentList argumentList) {
     this._constructorName = becomeParentOf(constructorName);
     this._argumentList = becomeParentOf(argumentList);
   }
 
+  @override
   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;
 
+  @override
   Token get beginToken => keyword;
 
   /**
    * Return the name of the constructor that is being invoked, or `null` if the unnamed
    * constructor is being invoked.
    *
    * @return the name of the constructor that is being invoked
    */
   SimpleIdentifier get constructorName => _constructorName;
 
+  @override
   Token get endToken => _argumentList.endToken;
 
   /**
    * Set the list of arguments to the constructor to the given list.
    *
    * @param argumentList the list of arguments to the constructor
    */
   void set argumentList(ArgumentList argumentList) {
     this._argumentList = becomeParentOf(argumentList);
   }
 
   /**
    * 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 constructorName(SimpleIdentifier identifier) {
     _constructorName = becomeParentOf(identifier);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 
 /**
  * Instances of the class `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(this.keyword);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitSuperExpression(this);
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   Token get endToken => keyword;
 
+  @override
   int get precedence => 16;
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `SwitchCase` represent the case in a switch statement.
  *
  * <pre>
  * switchCase ::=
  *     [SimpleIdentifier]* 'case' [Expression] ':' [Statement]*
@@ skipping 11 matching lines @@
    * @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) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   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 expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     labels.accept(visitor);
     safelyVisitChild(_expression, visitor);
     statements.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `SwitchDefault` represent the default case in a switch statement.
  *
  * <pre>
  * switchDefault ::=
  *     [SimpleIdentifier]* 'default' ':' [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);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitSwitchDefault(this);
 
+  @override
   void visitChildren(AstVisitor visitor) {
     labels.accept(visitor);
     statements.accept(visitor);
   }
 }
 
 /**
  * The abstract class `SwitchMember` defines the behavior common to objects representing
  * elements within a switch statement.
  *
@@ skipping 32 matching lines @@
    * @param colon the colon separating the keyword or the expression from the statements
    * @param statements the statements that will be executed if this switch member is selected
    */
   SwitchMember(List<Label> labels, this.keyword, this.colon, List<Statement> statements) {
     this._labels = new NodeList<Label>(this);
     this._statements = new NodeList<Statement>(this);
     this._labels.addAll(labels);
     this._statements.addAll(statements);
   }
 
+  @override
   Token get beginToken {
     if (!_labels.isEmpty) {
       return _labels.beginToken;
     }
     return keyword;
   }
 
+  @override
   Token get endToken {
     if (!_statements.isEmpty) {
       return _statements.endToken;
     }
     return colon;
   }
 
   /**
    * Return the labels associated with the switch member.
    *
@@ skipping 63 matching lines @@
    * @param leftBracket the left curly bracket
    * @param members the switch members that can be selected by the expression
    * @param rightBracket the right curly bracket
    */
   SwitchStatement(this.keyword, this.leftParenthesis, Expression expression, this.rightParenthesis, this.leftBracket, List<SwitchMember> members, this.rightBracket) {
     this._members = new NodeList<SwitchMember>(this);
     this._expression = becomeParentOf(expression);
     this._members.addAll(members);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitSwitchStatement(this);
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   Token get endToken => rightBracket;
 
   /**
    * Return the expression used to determine which of the switch members will be selected.
    *
    * @return the expression used to determine which of the switch members will be selected
    */
   Expression get expression => _expression;
 
   /**
    * Return the switch members that can be selected by the expression.
    *
    * @return the switch members that can be selected by the expression
    */
   NodeList<SwitchMember> get members => _members;
 
   /**
    * Set the expression used to determine which of the switch members will be selected to the given
    * expression.
    *
    * @param expression the expression used to determine which of the switch members will be selected
    */
   void set expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     _members.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `SymbolLiteral` represent a symbol literal expression.
  *
  * <pre>
@@ skipping 13 matching lines @@
   final List<Token> components;
 
   /**
    * Initialize a newly created symbol literal.
    *
    * @param poundSign the token introducing the literal
    * @param components the components of the literal
    */
   SymbolLiteral(this.poundSign, this.components);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitSymbolLiteral(this);
 
+  @override
   Token get beginToken => poundSign;
 
+  @override
   Token get endToken => components[components.length - 1];
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `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(this.keyword);
 
+  @override
   accept(AstVisitor visitor) => visitor.visitThisExpression(this);
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   Token get endToken => keyword;
 
+  @override
   int get precedence => 16;
 
+  @override
   void visitChildren(AstVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `ThrowExpression` represent a throw expression.
  *
  * <pre>
  * throwExpression ::=
  *     'throw' [Expression]
@@ skipping 13 matching lines @@
   /**
    * Initialize a newly created throw expression.
    *
    * @param keyword the token representing the 'throw' keyword
    * @param expression the expression computing the exception to be thrown
    */
   ThrowExpression(this.keyword, Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitThrowExpression(this);
 
+  @override
   Token get beginToken => keyword;
 
+  @override
   Token get endToken {
     if (_expression != null) {
       return _expression.endToken;
     }
     return keyword;
   }
 
   /**
    * Return the expression computing the exception to be thrown.
    *
    * @return the expression computing the exception to be thrown
    */
   Expression get expression => _expression;
 
+  @override
   int get precedence => 0;
 
   /**
    * 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 expression(Expression expression) {
     this._expression = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 
 /**
  * Instances of the class `TopLevelVariableDeclaration` represent the declaration of one or
  * more top-level variables of the same type.
  *
  * <pre>
@@ skipping 18 matching lines @@
    *
    * @param comment the documentation comment associated with this variable
    * @param metadata the annotations associated with this variable
    * @param variableList the top-level variables being declared
    * @param semicolon the semicolon terminating the declaration
    */
   TopLevelVariableDeclaration(Comment comment, List<Annotation> metadata, VariableDeclarationList variableList, this.semicolon) : super(comment, metadata) {
     this._variableList = becomeParentOf(variableList);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitTopLevelVariableDeclaration(this);
 
+  @override
   Element get element => null;
 
+  @override
   Token get endToken => semicolon;
 
   /**
    * Return the top-level variables being declared.
    *
    * @return the top-level variables being declared
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the top-level variables being declared to the given list of variables.
    *
    * @param variableList the top-level variables being declared
    */
   void set variables(VariableDeclarationList variableList) {
     variableList = becomeParentOf(variableList);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_variableList, visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
 }
 
 /**
  * Instances of the class `TryStatement` represent a try statement.
  *
  * <pre>
  * tryStatement ::=
  *     'try' [Block] ([CatchClause]+ finallyClause? | finallyClause)
  *
@@ skipping 38 matching lines @@
    * @param finallyKeyword the token representing the 'finally' keyword
    * @param finallyBlock the finally block contained in the try statement
    */
   TryStatement(this.tryKeyword, Block body, List<CatchClause> catchClauses, this.finallyKeyword, Block finallyBlock) {
     this._catchClauses = new NodeList<CatchClause>(this);
     this._body = becomeParentOf(body);
     this._catchClauses.addAll(catchClauses);
     this._finallyBlock = becomeParentOf(finallyBlock);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitTryStatement(this);
 
+  @override
   Token get beginToken => tryKeyword;
 
   /**
    * Return the body of the statement.
    *
    * @return the body of the statement
    */
   Block get body => _body;
 
   /**
    * Return the catch clauses contained in the try statement.
    *
    * @return the catch clauses contained in the try statement
    */
   NodeList<CatchClause> get catchClauses => _catchClauses;
 
+  @override
   Token get endToken {
     if (_finallyBlock != null) {
       return _finallyBlock.endToken;
     } else if (finallyKeyword != null) {
       return finallyKeyword;
     } else if (!_catchClauses.isEmpty) {
       return _catchClauses.endToken;
     }
     return _body.endToken;
   }
@@ skipping 17 matching lines @@
 
   /**
    * Set the finally block contained in the try statement to the given block.
    *
    * @param block the finally block contained in the try statement
    */
   void set finallyBlock(Block block) {
     _finallyBlock = becomeParentOf(block);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_body, visitor);
     _catchClauses.accept(visitor);
     safelyVisitChild(_finallyBlock, visitor);
   }
 }
 
 /**
  * The abstract class `TypeAlias` defines the behavior common to declarations of type aliases.
  *
@@ skipping 20 matching lines @@
   /**
    * Initialize a newly created type alias.
    *
    * @param comment the documentation comment associated with this type alias
    * @param metadata the annotations associated with this type alias
    * @param keyword the token representing the 'typedef' keyword
    * @param semicolon the semicolon terminating the declaration
    */
   TypeAlias(Comment comment, List<Annotation> metadata, this.keyword, this.semicolon) : super(comment, metadata);
 
+  @override
   Token get endToken => semicolon;
 
+  @override
   Token get firstTokenAfterCommentAndMetadata => keyword;
 }
 
 /**
  * Instances of the class `TypeArgumentList` represent a list of type arguments.
  *
  * <pre>
  * typeArguments ::=
  *     '<' typeName (',' typeName)* '>'
  * </pre>
@@ skipping 19 matching lines @@
    *
    * @param leftBracket the left bracket
    * @param arguments the type arguments associated with the type
    * @param rightBracket the right bracket
    */
   TypeArgumentList(this.leftBracket, List<TypeName> arguments, this.rightBracket) {
     this._arguments = new NodeList<TypeName>(this);
     this._arguments.addAll(arguments);
   }
 
+  @override
   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;
 
+  @override
   Token get beginToken => leftBracket;
 
+  @override
   Token get endToken => rightBracket;
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _arguments.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `TypeName` represent the name of a type, which can optionally
  * include type arguments.
  *
  * <pre>
@@ skipping 22 matching lines @@
    *
    * @param name the name of the type
    * @param typeArguments the type arguments associated with the type, or `null` if there are
    *          no type arguments
    */
   TypeName(Identifier name, TypeArgumentList typeArguments) {
     this._name = becomeParentOf(name);
     this._typeArguments = becomeParentOf(typeArguments);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitTypeName(this);
 
+  @override
   Token get beginToken => _name.beginToken;
 
+  @override
   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 arguments associated with the type, or `null` if there are no type
    * arguments.
    *
    * @return the type arguments associated with the type
    */
   TypeArgumentList get typeArguments => _typeArguments;
 
+  @override
   bool get isSynthetic => _name.isSynthetic && _typeArguments == null;
 
   /**
    * Set the name of the type to the given identifier.
    *
    * @param identifier the name of the type
    */
   void set name(Identifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
   /**
    * Set the type arguments associated with the type to the given type arguments.
    *
    * @param typeArguments the type arguments associated with the type
    */
   void set typeArguments(TypeArgumentList typeArguments) {
     this._typeArguments = becomeParentOf(typeArguments);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 
 /**
  * Instances of the class `TypeParameter` represent a type parameter.
  *
  * <pre>
@@ skipping 26 matching lines @@
    * @param metadata the annotations associated with the type parameter
    * @param name the name of the type parameter
    * @param keyword the token representing the 'extends' keyword
    * @param bound the name of the upper bound for legal arguments
    */
   TypeParameter(Comment comment, List<Annotation> metadata, SimpleIdentifier name, this.keyword, TypeName bound) : super(comment, metadata) {
     this._name = becomeParentOf(name);
     this._bound = becomeParentOf(bound);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitTypeParameter(this);
 
   /**
    * Return the name of the upper bound for legal arguments, or `null` if there was no
    * explicit upper bound.
    *
    * @return the name of the upper bound for legal arguments
    */
   TypeName get bound => _bound;
 
+  @override
   TypeParameterElement get element => _name != null ? (_name.staticElement as TypeParameterElement) : null;
 
+  @override
   Token get endToken {
     if (_bound == null) {
       return _name.endToken;
     }
     return _bound.endToken;
   }
 
   /**
    * Return the name of the type parameter.
    *
@@ skipping 12 matching lines @@
 
   /**
    * Set the name of the type parameter to the given identifier.
    *
    * @param identifier the name of the type parameter
    */
   void set name(SimpleIdentifier identifier) {
     _name = becomeParentOf(identifier);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_bound, visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 
 /**
  * Instances of the class `TypeParameterList` represent type parameters within a declaration.
  *
  * <pre>
  * typeParameterList ::=
  *     '<' [TypeParameter] (',' [TypeParameter])* '>'
  * </pre>
@@ skipping 19 matching lines @@
    *
    * @param leftBracket the left angle bracket
    * @param typeParameters the type parameters in the list
    * @param rightBracket the right angle bracket
    */
   TypeParameterList(this.leftBracket, List<TypeParameter> typeParameters, this.rightBracket) {
     this._typeParameters = new NodeList<TypeParameter>(this);
     this._typeParameters.addAll(typeParameters);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitTypeParameterList(this);
 
+  @override
   Token get beginToken => leftBracket;
 
+  @override
   Token get endToken => rightBracket;
 
   /**
    * Return the type parameters for the type.
    *
    * @return the type parameters for the type
    */
   NodeList<TypeParameter> get typeParameters => _typeParameters;
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _typeParameters.accept(visitor);
   }
 }
 
 /**
  * The abstract class `TypedLiteral` defines the behavior common to literals that have a type
  * associated with them.
  *
  * <pre>
@@ skipping 18 matching lines @@
    * Initialize a newly created typed literal.
    *
    * @param constKeyword the token representing the 'const' keyword
    * @param typeArguments the type argument associated with this literal, or `null` if no type
    *          arguments were declared
    */
   TypedLiteral(this.constKeyword, TypeArgumentList typeArguments) {
     this.typeArguments = becomeParentOf(typeArguments);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(typeArguments, visitor);
   }
 }
 
 /**
  * The abstract class `UriBasedDirective` defines the behavior common to nodes that represent
  * a directive that references a URI.
  *
  * <pre>
@@ skipping 38 matching lines @@
 
   /**
    * Set the URI referenced by this directive to the given URI.
    *
    * @param uri the URI referenced by this directive
    */
   void set uri(StringLiteral uri) {
     this._uri = becomeParentOf(uri);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_uri, visitor);
   }
 }
 
 /**
  * Instances of the class `VariableDeclaration` represent an identifier that has an initial
  * value associated with it. Instances of this class are always children of the class
  * [VariableDeclarationList].
@@ skipping 28 matching lines @@
    * @param metadata the annotations associated with this member
    * @param name the name of the variable being declared
    * @param equals the equal sign separating the variable name from the initial value
    * @param initializer the expression used to compute the initial value for the variable
    */
   VariableDeclaration(Comment comment, List<Annotation> metadata, SimpleIdentifier name, this.equals, Expression initializer) : super(comment, metadata) {
     this._name = becomeParentOf(name);
     this._initializer = becomeParentOf(initializer);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitVariableDeclaration(this);
 
   /**
    * This overridden implementation of getDocumentationComment() looks in the grandparent node for
    * dartdoc comments if no documentation is specifically available on the node.
    */
+  @override
   Comment get documentationComment {
     Comment comment = super.documentationComment;
     if (comment == null) {
       if (parent != null && parent.parent != null) {
         AstNode node = parent.parent;
         if (node is AnnotatedNode) {
           return node.documentationComment;
         }
       }
     }
     return comment;
   }
 
+  @override
   VariableElement get element => _name != null ? (_name.staticElement as VariableElement) : null;
 
+  @override
   Token get endToken {
     if (_initializer != null) {
       return _initializer.endToken;
     }
     return _name.endToken;
   }
 
   /**
    * Return the expression used to compute the initial value for the variable, or `null` if
    * the initial value was not specified.
@@ skipping 42 matching lines @@
 
   /**
    * 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 name) {
     this._name = becomeParentOf(name);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_initializer, visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 
 /**
  * Instances of the class `VariableDeclarationList` represent the declaration of one or more
  * variables of the same type.
  *
  * <pre>
  * variableDeclarationList ::=
  *     finalConstVarOrType [VariableDeclaration] (',' [VariableDeclaration])*
@@ skipping 30 matching lines @@
    * @param keyword the token representing the 'final', 'const' or 'var' keyword
    * @param type the type of the variables being declared
    * @param variables a list containing the individual variables being declared
    */
   VariableDeclarationList(Comment comment, List<Annotation> metadata, this.keyword, TypeName type, List<VariableDeclaration> variables) : super(comment, metadata) {
     this._variables = new NodeList<VariableDeclaration>(this);
     this._type = becomeParentOf(type);
     this._variables.addAll(variables);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitVariableDeclarationList(this);
 
+  @override
   Token get endToken => _variables.endToken;
 
   /**
    * Return the type of the variables being declared, or `null` if no type was provided.
    *
    * @return the type of the variables being declared
    */
   TypeName get type => _type;
 
   /**
@@ skipping 21 matching lines @@
 
   /**
    * Set the type of the variables being declared to the given type name.
    *
    * @param typeName the type of the variables being declared
    */
   void set type(TypeName typeName) {
     _type = becomeParentOf(typeName);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_type, visitor);
     _variables.accept(visitor);
   }
 
+  @override
   Token get firstTokenAfterCommentAndMetadata {
     if (keyword != null) {
       return keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return _variables.beginToken;
   }
 }
 
@@ skipping 20 matching lines @@
   /**
    * Initialize a newly created variable declaration statement.
    *
    * @param variableList the fields being declared
    * @param semicolon the semicolon terminating the statement
    */
   VariableDeclarationStatement(VariableDeclarationList variableList, this.semicolon) {
     this._variableList = becomeParentOf(variableList);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitVariableDeclarationStatement(this);
 
+  @override
   Token get beginToken => _variableList.beginToken;
 
+  @override
   Token get endToken => semicolon;
 
   /**
    * Return the variables being declared.
    *
    * @return the variables being declared
    */
   VariableDeclarationList get variables => _variableList;
 
   /**
    * Set the variables being declared to the given list of variables.
    *
    * @param variableList the variables being declared
    */
   void set variables(VariableDeclarationList variableList) {
     this._variableList = becomeParentOf(variableList);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_variableList, visitor);
   }
 }
 
 /**
  * Instances of the class `WhileStatement` represent a while statement.
  *
  * <pre>
  * whileStatement ::=
@@ skipping 33 matching lines @@
    * @param leftParenthesis the left parenthesis
    * @param condition the expression used to determine whether to execute the body of the loop
    * @param rightParenthesis the right parenthesis
    * @param body the body of the loop
    */
   WhileStatement(this.keyword, this.leftParenthesis, Expression condition, this.rightParenthesis, Statement body) {
     this._condition = becomeParentOf(condition);
     this._body = becomeParentOf(body);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitWhileStatement(this);
 
+  @override
   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
    */
   Expression get condition => _condition;
 
+  @override
   Token get endToken => _body.endToken;
 
   /**
    * Set the body of the loop to the given statement.
    *
    * @param statement the body of the loop
    */
   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 condition(Expression expression) {
     _condition = becomeParentOf(expression);
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 
 /**
  * Instances of the class `WithClause` represent the with clause in a class declaration.
  *
  * <pre>
@@ skipping 17 matching lines @@
    *
    * @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._mixinTypes = new NodeList<TypeName>(this);
     this._withKeyword = withKeyword;
     this._mixinTypes.addAll(mixinTypes);
   }
 
+  @override
   accept(AstVisitor visitor) => visitor.visitWithClause(this);
 
+  @override
   Token get beginToken => _withKeyword;
 
+  @override
   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;
   }
 
+  @override
   void visitChildren(AstVisitor visitor) {
     _mixinTypes.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `BreadthFirstVisitor` implement an AST visitor that will recursively
  * visit all of the nodes in an AST structure, similar to [GeneralizingAstVisitor]. This
  * visitor uses a breadth-first ordering rather than the depth-first ordering of
  * [GeneralizingAstVisitor].
@@ skipping 26 matching lines @@
    * @param root the root of the AST structure to be visited
    */
   void visitAllNodes(AstNode root) {
     _queue.add(root);
     while (!_queue.isEmpty) {
       AstNode next = _queue.removeFirst();
       next.accept(this);
     }
   }
 
+  @override
   R visitNode(AstNode node) {
     node.visitChildren(_childVisitor);
     return null;
   }
 
   BreadthFirstVisitor() {
     this._childVisitor = new GeneralizingAstVisitor_BreadthFirstVisitor(this);
   }
 }
 
 class GeneralizingAstVisitor_BreadthFirstVisitor extends GeneralizingAstVisitor<Object> {
   final BreadthFirstVisitor BreadthFirstVisitor_this;
 
   GeneralizingAstVisitor_BreadthFirstVisitor(this.BreadthFirstVisitor_this) : super();
 
+  @override
   Object visitNode(AstNode node) {
     BreadthFirstVisitor_this._queue.add(node);
     return null;
   }
 }
 
 /**
  * Instances of the class `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:
@@ skipping 30 matching lines @@
  * conditions encountered during evaluation. These are documented with the static field that define
  * those values.
  */
 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();
 
+  @override
   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);
     }
     return builder.toString();
   }
 
+  @override
   Object visitBinaryExpression(BinaryExpression node) {
     Object leftOperand = node.leftOperand.accept(this);
     if (identical(leftOperand, NOT_A_CONSTANT)) {
       return leftOperand;
     }
     Object rightOperand = node.rightOperand.accept(this);
     if (identical(rightOperand, NOT_A_CONSTANT)) {
       return rightOperand;
     }
     while (true) {
@@ skipping 133 matching lines @@
           return leftOperand ~/ rightOperand;
         }
       } else {
       }
       break;
     }
     // TODO(brianwilkerson) This doesn't handle numeric conversions.
     return visitExpression(node);
   }
 
+  @override
   Object visitBooleanLiteral(BooleanLiteral node) => node.value ? true : false;
 
+  @override
   Object visitDoubleLiteral(DoubleLiteral node) => node.value;
 
+  @override
   Object visitIntegerLiteral(IntegerLiteral node) => node.value;
 
+  @override
   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;
   }
 
+  @override
   Object visitInterpolationString(InterpolationString node) => node.value;
 
+  @override
   Object visitListLiteral(ListLiteral node) {
     List<Object> list = new List<Object>();
     for (Expression element in node.elements) {
       Object value = element.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
       list.add(value);
     }
     return list;
   }
 
+  @override
   Object visitMapLiteral(MapLiteral node) {
     Map<String, Object> map = new Map<String, Object>();
     for (MapLiteralEntry entry in node.entries) {
       Object key = entry.key.accept(this);
       Object value = entry.value.accept(this);
       if (key is! String || identical(value, NOT_A_CONSTANT)) {
         return NOT_A_CONSTANT;
       }
       map[(key as String)] = value;
     }
     return map;
   }
 
+  @override
   Object visitMethodInvocation(MethodInvocation node) => visitNode(node);
 
+  @override
   Object visitNode(AstNode node) => NOT_A_CONSTANT;
 
+  @override
   Object visitNullLiteral(NullLiteral node) => null;
 
+  @override
   Object visitParenthesizedExpression(ParenthesizedExpression node) => node.expression.accept(this);
 
+  @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) => _getConstantValue(null);
 
+  @override
   Object visitPrefixExpression(PrefixExpression node) {
     Object operand = node.operand.accept(this);
     if (identical(operand, NOT_A_CONSTANT)) {
       return operand;
     }
     while (true) {
       if (node.operator.type == TokenType.BANG) {
         if (identical(operand, true)) {
           return false;
         } else if (identical(operand, false)) {
@@ skipping 11 matching lines @@
         } else if (operand is double) {
           return -operand;
         }
       } else {
       }
       break;
     }
     return NOT_A_CONSTANT;
   }
 
+  @override
   Object visitPropertyAccess(PropertyAccess node) => _getConstantValue(null);
 
+  @override
   Object visitSimpleIdentifier(SimpleIdentifier node) => _getConstantValue(null);
 
+  @override
   Object visitSimpleStringLiteral(SimpleStringLiteral node) => node.value;
 
+  @override
   Object visitStringInterpolation(StringInterpolation node) {
     JavaStringBuilder builder = new JavaStringBuilder();
     for (InterpolationElement element in node.elements) {
       Object value = element.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
       builder.append(value);
     }
     return builder.toString();
   }
 
+  @override
   Object visitSymbolLiteral(SymbolLiteral node) {
     // TODO(brianwilkerson) This isn't optimal because a Symbol is not a String.
     JavaStringBuilder builder = new JavaStringBuilder();
     for (Token component in node.components) {
       if (builder.length > 0) {
         builder.appendChar(0x2E);
       }
       builder.append(component.lexeme);
     }
     return builder.toString();
@@ skipping 56 matching lines @@
     }
     // no Element
     return null;
   }
 }
 
 /**
  * Visitor that maps nodes to elements.
  */
 class ElementLocator_ElementMapper extends GeneralizingAstVisitor<Element> {
+  @override
   Element visitAssignmentExpression(AssignmentExpression node) => node.bestElement;
 
+  @override
   Element visitBinaryExpression(BinaryExpression node) => node.bestElement;
 
+  @override
   Element visitClassDeclaration(ClassDeclaration node) => node.element;
 
+  @override
   Element visitCompilationUnit(CompilationUnit node) => node.element;
 
+  @override
   Element visitConstructorDeclaration(ConstructorDeclaration node) => node.element;
 
+  @override
   Element visitFunctionDeclaration(FunctionDeclaration node) => node.element;
 
+  @override
   Element visitIdentifier(Identifier node) {
     AstNode parent = node.parent;
     // Type name in InstanceCreationExpression
     {
       AstNode typeNameCandidate = parent;
       // new prefix.node[.constructorName]()
       if (typeNameCandidate is PrefixedIdentifier) {
         PrefixedIdentifier prefixedIdentifier = typeNameCandidate as PrefixedIdentifier;
         if (identical(prefixedIdentifier.identifier, node)) {
           typeNameCandidate = prefixedIdentifier.parent;
@@ skipping 32 matching lines @@
         }
       }
     }
     Element element = node.bestElement;
     if (element == null) {
       element = node.staticElement;
     }
     return element;
   }
 
+  @override
   Element visitImportDirective(ImportDirective node) => node.element;
 
+  @override
   Element visitIndexExpression(IndexExpression node) => node.bestElement;
 
+  @override
   Element visitInstanceCreationExpression(InstanceCreationExpression node) => node.staticElement;
 
+  @override
   Element visitLibraryDirective(LibraryDirective node) => node.element;
 
+  @override
   Element visitMethodDeclaration(MethodDeclaration node) => node.element;
 
+  @override
   Element visitMethodInvocation(MethodInvocation node) => node.methodName.bestElement;
 
+  @override
   Element visitPostfixExpression(PostfixExpression node) => node.bestElement;
 
+  @override
   Element visitPrefixedIdentifier(PrefixedIdentifier node) => node.bestElement;
 
+  @override
   Element visitPrefixExpression(PrefixExpression node) => node.bestElement;
 
+  @override
   Element visitStringLiteral(StringLiteral node) {
     AstNode parent = node.parent;
     if (parent is UriBasedDirective) {
       return parent.uriElement;
     }
     return null;
   }
 
+  @override
   Element visitVariableDeclaration(VariableDeclaration node) => node.element;
 }
 
 /**
  * Instances of the class `GeneralizingAstVisitor` implement an AST visitor that will
  * recursively visit all of the nodes in an AST structure (like instances of the class
  * [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
  * superclasses of that node will also be invoked. For example, using an instance of this class to
  * visit a [Block] will cause the method [visitBlock] to be invoked but will
  * also cause the methods [visitStatement] and [visitNode] to be
  * subsequently invoked. This allows visitors to be written that visit all statements without
  * needing to override the visit method for each of the specific subclasses of [Statement].
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or
  * explicitly invoke the more general visit method. Failure to do so will cause the visit methods
  * for superclasses of the node to not be invoked and will cause the children of the visited node to
  * not be visited.
  */
 class GeneralizingAstVisitor<R> implements AstVisitor<R> {
+  @override
   R visitAdjacentStrings(AdjacentStrings node) => visitStringLiteral(node);
 
   R visitAnnotatedNode(AnnotatedNode node) => visitNode(node);
 
+  @override
   R visitAnnotation(Annotation node) => visitNode(node);
 
+  @override
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node) => visitExpression(node);
 
+  @override
   R visitArgumentList(ArgumentList node) => visitNode(node);
 
+  @override
   R visitAsExpression(AsExpression node) => visitExpression(node);
 
+  @override
   R visitAssertStatement(AssertStatement node) => visitStatement(node);
 
+  @override
   R visitAssignmentExpression(AssignmentExpression node) => visitExpression(node);
 
+  @override
   R visitBinaryExpression(BinaryExpression node) => visitExpression(node);
 
+  @override
   R visitBlock(Block node) => visitStatement(node);
 
+  @override
   R visitBlockFunctionBody(BlockFunctionBody node) => visitFunctionBody(node);
 
+  @override
   R visitBooleanLiteral(BooleanLiteral node) => visitLiteral(node);
 
+  @override
   R visitBreakStatement(BreakStatement node) => visitStatement(node);
 
+  @override
   R visitCascadeExpression(CascadeExpression node) => visitExpression(node);
 
+  @override
   R visitCatchClause(CatchClause node) => visitNode(node);
 
+  @override
   R visitClassDeclaration(ClassDeclaration node) => visitCompilationUnitMember(node);
 
   R visitClassMember(ClassMember node) => visitDeclaration(node);
 
+  @override
   R visitClassTypeAlias(ClassTypeAlias node) => visitTypeAlias(node);
 
   R visitCombinator(Combinator node) => visitNode(node);
 
+  @override
   R visitComment(Comment node) => visitNode(node);
 
+  @override
   R visitCommentReference(CommentReference node) => visitNode(node);
 
+  @override
   R visitCompilationUnit(CompilationUnit node) => visitNode(node);
 
   R visitCompilationUnitMember(CompilationUnitMember node) => visitDeclaration(node);
 
+  @override
   R visitConditionalExpression(ConditionalExpression node) => visitExpression(node);
 
+  @override
   R visitConstructorDeclaration(ConstructorDeclaration node) => visitClassMember(node);
 
+  @override
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node) => visitConstructorInitializer(node);
 
   R visitConstructorInitializer(ConstructorInitializer node) => visitNode(node);
 
+  @override
   R visitConstructorName(ConstructorName node) => visitNode(node);
 
+  @override
   R visitContinueStatement(ContinueStatement node) => visitStatement(node);
 
   R visitDeclaration(Declaration node) => visitAnnotatedNode(node);
 
+  @override
   R visitDeclaredIdentifier(DeclaredIdentifier node) => visitDeclaration(node);
 
+  @override
   R visitDefaultFormalParameter(DefaultFormalParameter node) => visitFormalParameter(node);
 
   R visitDirective(Directive node) => visitAnnotatedNode(node);
 
+  @override
   R visitDoStatement(DoStatement node) => visitStatement(node);
 
+  @override
   R visitDoubleLiteral(DoubleLiteral node) => visitLiteral(node);
 
+  @override
   R visitEmptyFunctionBody(EmptyFunctionBody node) => visitFunctionBody(node);
 
+  @override
   R visitEmptyStatement(EmptyStatement node) => visitStatement(node);
 
+  @override
   R visitExportDirective(ExportDirective node) => visitNamespaceDirective(node);
 
   R visitExpression(Expression node) => visitNode(node);
 
+  @override
   R visitExpressionFunctionBody(ExpressionFunctionBody node) => visitFunctionBody(node);
 
+  @override
   R visitExpressionStatement(ExpressionStatement node) => visitStatement(node);
 
+  @override
   R visitExtendsClause(ExtendsClause node) => visitNode(node);
 
+  @override
   R visitFieldDeclaration(FieldDeclaration node) => visitClassMember(node);
 
+  @override
   R visitFieldFormalParameter(FieldFormalParameter node) => visitNormalFormalParameter(node);
 
+  @override
   R visitForEachStatement(ForEachStatement node) => visitStatement(node);
 
   R visitFormalParameter(FormalParameter node) => visitNode(node);
 
+  @override
   R visitFormalParameterList(FormalParameterList node) => visitNode(node);
 
+  @override
   R visitForStatement(ForStatement node) => visitStatement(node);
 
   R visitFunctionBody(FunctionBody node) => visitNode(node);
 
+  @override
   R visitFunctionDeclaration(FunctionDeclaration node) => visitCompilationUnitMember(node);
 
+  @override
   R visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => visitStatement(node);
 
+  @override
   R visitFunctionExpression(FunctionExpression node) => visitExpression(node);
 
+  @override
   R visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => visitExpression(node);
 
+  @override
   R visitFunctionTypeAlias(FunctionTypeAlias node) => visitTypeAlias(node);
 
+  @override
   R visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => visitNormalFormalParameter(node);
 
+  @override
   R visitHideCombinator(HideCombinator node) => visitCombinator(node);
 
   R visitIdentifier(Identifier node) => visitExpression(node);
 
+  @override
   R visitIfStatement(IfStatement node) => visitStatement(node);
 
+  @override
   R visitImplementsClause(ImplementsClause node) => visitNode(node);
 
+  @override
   R visitImportDirective(ImportDirective node) => visitNamespaceDirective(node);
 
+  @override
   R visitIndexExpression(IndexExpression node) => visitExpression(node);
 
+  @override
   R visitInstanceCreationExpression(InstanceCreationExpression node) => visitExpression(node);
 
+  @override
   R visitIntegerLiteral(IntegerLiteral node) => visitLiteral(node);
 
   R visitInterpolationElement(InterpolationElement node) => visitNode(node);
 
+  @override
   R visitInterpolationExpression(InterpolationExpression node) => visitInterpolationElement(node);
 
+  @override
   R visitInterpolationString(InterpolationString node) => visitInterpolationElement(node);
 
+  @override
   R visitIsExpression(IsExpression node) => visitExpression(node);
 
+  @override
   R visitLabel(Label node) => visitNode(node);
 
+  @override
   R visitLabeledStatement(LabeledStatement node) => visitStatement(node);
 
+  @override
   R visitLibraryDirective(LibraryDirective node) => visitDirective(node);
 
+  @override
   R visitLibraryIdentifier(LibraryIdentifier node) => visitIdentifier(node);
 
+  @override
   R visitListLiteral(ListLiteral node) => visitTypedLiteral(node);
 
   R visitLiteral(Literal node) => visitExpression(node);
 
+  @override
   R visitMapLiteral(MapLiteral node) => visitTypedLiteral(node);
 
+  @override
   R visitMapLiteralEntry(MapLiteralEntry node) => visitNode(node);
 
+  @override
   R visitMethodDeclaration(MethodDeclaration node) => visitClassMember(node);
 
+  @override
   R visitMethodInvocation(MethodInvocation node) => visitExpression(node);
 
+  @override
   R visitNamedExpression(NamedExpression node) => visitExpression(node);
 
   R visitNamespaceDirective(NamespaceDirective node) => visitUriBasedDirective(node);
 
+  @override
   R visitNativeClause(NativeClause node) => visitNode(node);
 
+  @override
   R visitNativeFunctionBody(NativeFunctionBody node) => visitFunctionBody(node);
 
   R visitNode(AstNode node) {
     node.visitChildren(this);
     return null;
   }
 
   R visitNormalFormalParameter(NormalFormalParameter node) => visitFormalParameter(node);
 
+  @override
   R visitNullLiteral(NullLiteral node) => visitLiteral(node);
 
+  @override
   R visitParenthesizedExpression(ParenthesizedExpression node) => visitExpression(node);
 
+  @override
   R visitPartDirective(PartDirective node) => visitUriBasedDirective(node);
 
+  @override
   R visitPartOfDirective(PartOfDirective node) => visitDirective(node);
 
+  @override
   R visitPostfixExpression(PostfixExpression node) => visitExpression(node);
 
+  @override
   R visitPrefixedIdentifier(PrefixedIdentifier node) => visitIdentifier(node);
 
+  @override
   R visitPrefixExpression(PrefixExpression node) => visitExpression(node);
 
+  @override
   R visitPropertyAccess(PropertyAccess node) => visitExpression(node);
 
+  @override
   R visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) => visitConstructorInitializer(node);
 
+  @override
   R visitRethrowExpression(RethrowExpression node) => visitExpression(node);
 
+  @override
   R visitReturnStatement(ReturnStatement node) => visitStatement(node);
 
+  @override
   R visitScriptTag(ScriptTag scriptTag) => visitNode(scriptTag);
 
+  @override
   R visitShowCombinator(ShowCombinator node) => visitCombinator(node);
 
+  @override
   R visitSimpleFormalParameter(SimpleFormalParameter node) => visitNormalFormalParameter(node);
 
+  @override
   R visitSimpleIdentifier(SimpleIdentifier node) => visitIdentifier(node);
 
+  @override
   R visitSimpleStringLiteral(SimpleStringLiteral node) => visitStringLiteral(node);
 
   R visitStatement(Statement node) => visitNode(node);
 
+  @override
   R visitStringInterpolation(StringInterpolation node) => visitStringLiteral(node);
 
   R visitStringLiteral(StringLiteral node) => visitLiteral(node);
 
+  @override
   R visitSuperConstructorInvocation(SuperConstructorInvocation node) => visitConstructorInitializer(node);
 
+  @override
   R visitSuperExpression(SuperExpression node) => visitExpression(node);
 
+  @override
   R visitSwitchCase(SwitchCase node) => visitSwitchMember(node);
 
+  @override
   R visitSwitchDefault(SwitchDefault node) => visitSwitchMember(node);
 
   R visitSwitchMember(SwitchMember node) => visitNode(node);
 
+  @override
   R visitSwitchStatement(SwitchStatement node) => visitStatement(node);
 
+  @override
   R visitSymbolLiteral(SymbolLiteral node) => visitLiteral(node);
 
+  @override
   R visitThisExpression(ThisExpression node) => visitExpression(node);
 
+  @override
   R visitThrowExpression(ThrowExpression node) => visitExpression(node);
 
+  @override
   R visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => visitCompilationUnitMember(node);
 
+  @override
   R visitTryStatement(TryStatement node) => visitStatement(node);
 
   R visitTypeAlias(TypeAlias node) => visitCompilationUnitMember(node);
 
+  @override
   R visitTypeArgumentList(TypeArgumentList node) => visitNode(node);
 
   R visitTypedLiteral(TypedLiteral node) => visitLiteral(node);
 
+  @override
   R visitTypeName(TypeName node) => visitNode(node);
 
+  @override
   R visitTypeParameter(TypeParameter node) => visitNode(node);
 
+  @override
   R visitTypeParameterList(TypeParameterList node) => visitNode(node);
 
   R visitUriBasedDirective(UriBasedDirective node) => visitDirective(node);
 
+  @override
   R visitVariableDeclaration(VariableDeclaration node) => visitDeclaration(node);
 
+  @override
   R visitVariableDeclarationList(VariableDeclarationList node) => visitNode(node);
 
+  @override
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => visitStatement(node);
 
+  @override
   R visitWhileStatement(WhileStatement node) => visitStatement(node);
 
+  @override
   R visitWithClause(WithClause node) => visitNode(node);
 }
 
 /**
  * Instances of the class `NodeLocator` locate the [AstNode] associated with a
  * source range, given the AST structure built from the source. More specifically, they will return
  * the [AstNode] with the shortest length whose source range completely encompasses
  * the specified range.
  */
 class NodeLocator extends UnifyingAstVisitor<Object> {
@@ skipping 56 matching lines @@
     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;
   }
 
+  @override
   Object visitNode(AstNode node) {
     int start = node.offset;
     int end = start + node.length;
     if (end < _startOffset) {
       return null;
     }
     if (start > _endOffset) {
       return null;
     }
     try {
@@ skipping 23 matching lines @@
 /**
  * Instances of the class `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 [Block] will also cause all of the statements in the block to be visited.
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or must
  * explicitly ask the visited node to visit its children. Failure to do so will cause the children
  * of the visited node to not be visited.
  */
 class RecursiveAstVisitor<R> implements AstVisitor<R> {
+  @override
   R visitAdjacentStrings(AdjacentStrings node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitAnnotation(Annotation node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitArgumentList(ArgumentList node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitAsExpression(AsExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitAssertStatement(AssertStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitAssignmentExpression(AssignmentExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitBinaryExpression(BinaryExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitBlock(Block node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitBlockFunctionBody(BlockFunctionBody node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitBooleanLiteral(BooleanLiteral node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitBreakStatement(BreakStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitCascadeExpression(CascadeExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitCatchClause(CatchClause node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitClassDeclaration(ClassDeclaration node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitClassTypeAlias(ClassTypeAlias node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitComment(Comment node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitCommentReference(CommentReference node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitCompilationUnit(CompilationUnit node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitConditionalExpression(ConditionalExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitConstructorDeclaration(ConstructorDeclaration node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitConstructorName(ConstructorName node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitContinueStatement(ContinueStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitDeclaredIdentifier(DeclaredIdentifier node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitDefaultFormalParameter(DefaultFormalParameter node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitDoStatement(DoStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitDoubleLiteral(DoubleLiteral node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitEmptyFunctionBody(EmptyFunctionBody node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitEmptyStatement(EmptyStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitExportDirective(ExportDirective node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitExpressionFunctionBody(ExpressionFunctionBody node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitExpressionStatement(ExpressionStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitExtendsClause(ExtendsClause node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFieldDeclaration(FieldDeclaration node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFieldFormalParameter(FieldFormalParameter node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitForEachStatement(ForEachStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFormalParameterList(FormalParameterList node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitForStatement(ForStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFunctionDeclaration(FunctionDeclaration node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFunctionExpression(FunctionExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFunctionTypeAlias(FunctionTypeAlias node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitHideCombinator(HideCombinator node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitIfStatement(IfStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitImplementsClause(ImplementsClause node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitImportDirective(ImportDirective node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitIndexExpression(IndexExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitInstanceCreationExpression(InstanceCreationExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitIntegerLiteral(IntegerLiteral node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitInterpolationExpression(InterpolationExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitInterpolationString(InterpolationString node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitIsExpression(IsExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitLabel(Label node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitLabeledStatement(LabeledStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitLibraryDirective(LibraryDirective node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitLibraryIdentifier(LibraryIdentifier node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitListLiteral(ListLiteral node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitMapLiteral(MapLiteral node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitMapLiteralEntry(MapLiteralEntry node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitMethodDeclaration(MethodDeclaration node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitMethodInvocation(MethodInvocation node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitNamedExpression(NamedExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitNativeClause(NativeClause node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitNativeFunctionBody(NativeFunctionBody node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitNullLiteral(NullLiteral node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitParenthesizedExpression(ParenthesizedExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitPartDirective(PartDirective node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitPartOfDirective(PartOfDirective node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitPostfixExpression(PostfixExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitPrefixedIdentifier(PrefixedIdentifier node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitPrefixExpression(PrefixExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitPropertyAccess(PropertyAccess node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitRethrowExpression(RethrowExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitReturnStatement(ReturnStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitScriptTag(ScriptTag node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitShowCombinator(ShowCombinator node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitSimpleFormalParameter(SimpleFormalParameter node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitSimpleIdentifier(SimpleIdentifier node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitSimpleStringLiteral(SimpleStringLiteral node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitStringInterpolation(StringInterpolation node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitSuperExpression(SuperExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitSwitchCase(SwitchCase node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitSwitchDefault(SwitchDefault node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitSwitchStatement(SwitchStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitSymbolLiteral(SymbolLiteral node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitThisExpression(ThisExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitThrowExpression(ThrowExpression node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitTryStatement(TryStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitTypeArgumentList(TypeArgumentList node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitTypeName(TypeName node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitTypeParameter(TypeParameter node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitTypeParameterList(TypeParameterList node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitVariableDeclaration(VariableDeclaration node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitVariableDeclarationList(VariableDeclarationList node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitWhileStatement(WhileStatement node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitWithClause(WithClause node) {
     node.visitChildren(this);
     return null;
   }
 }
 
 /**
  * Instances of the class `SimpleAstVisitor` implement an AST visitor that will do nothing
  * when visiting an AST node. It is intended to be a superclass for classes that use the visitor
  * pattern primarily as a dispatch mechanism (and hence don't need to recursively visit a whole
  * structure) and that only need to visit a small number of node types.
  */
 class SimpleAstVisitor<R> implements AstVisitor<R> {
+  @override
   R visitAdjacentStrings(AdjacentStrings node) => null;
 
+  @override
   R visitAnnotation(Annotation node) => null;
 
+  @override
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node) => null;
 
+  @override
   R visitArgumentList(ArgumentList node) => null;
 
+  @override
   R visitAsExpression(AsExpression node) => null;
 
+  @override
   R visitAssertStatement(AssertStatement node) => null;
 
+  @override
   R visitAssignmentExpression(AssignmentExpression node) => null;
 
+  @override
   R visitBinaryExpression(BinaryExpression node) => null;
 
+  @override
   R visitBlock(Block node) => null;
 
+  @override
   R visitBlockFunctionBody(BlockFunctionBody node) => null;
 
+  @override
   R visitBooleanLiteral(BooleanLiteral node) => null;
 
+  @override
   R visitBreakStatement(BreakStatement node) => null;
 
+  @override
   R visitCascadeExpression(CascadeExpression node) => null;
 
+  @override
   R visitCatchClause(CatchClause node) => null;
 
+  @override
   R visitClassDeclaration(ClassDeclaration node) => null;
 
+  @override
   R visitClassTypeAlias(ClassTypeAlias node) => null;
 
+  @override
   R visitComment(Comment node) => null;
 
+  @override
   R visitCommentReference(CommentReference node) => null;
 
+  @override
   R visitCompilationUnit(CompilationUnit node) => null;
 
+  @override
   R visitConditionalExpression(ConditionalExpression node) => null;
 
+  @override
   R visitConstructorDeclaration(ConstructorDeclaration node) => null;
 
+  @override
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node) => null;
 
+  @override
   R visitConstructorName(ConstructorName node) => null;
 
+  @override
   R visitContinueStatement(ContinueStatement node) => null;
 
+  @override
   R visitDeclaredIdentifier(DeclaredIdentifier node) => null;
 
+  @override
   R visitDefaultFormalParameter(DefaultFormalParameter node) => null;
 
+  @override
   R visitDoStatement(DoStatement node) => null;
 
+  @override
   R visitDoubleLiteral(DoubleLiteral node) => null;
 
+  @override
   R visitEmptyFunctionBody(EmptyFunctionBody node) => null;
 
+  @override
   R visitEmptyStatement(EmptyStatement node) => null;
 
+  @override
   R visitExportDirective(ExportDirective node) => null;
 
+  @override
   R visitExpressionFunctionBody(ExpressionFunctionBody node) => null;
 
+  @override
   R visitExpressionStatement(ExpressionStatement node) => null;
 
+  @override
   R visitExtendsClause(ExtendsClause node) => null;
 
+  @override
   R visitFieldDeclaration(FieldDeclaration node) => null;
 
+  @override
   R visitFieldFormalParameter(FieldFormalParameter node) => null;
 
+  @override
   R visitForEachStatement(ForEachStatement node) => null;
 
+  @override
   R visitFormalParameterList(FormalParameterList node) => null;
 
+  @override
   R visitForStatement(ForStatement node) => null;
 
+  @override
   R visitFunctionDeclaration(FunctionDeclaration node) => null;
 
+  @override
   R visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => null;
 
+  @override
   R visitFunctionExpression(FunctionExpression node) => null;
 
+  @override
   R visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => null;
 
+  @override
   R visitFunctionTypeAlias(FunctionTypeAlias node) => null;
 
+  @override
   R visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => null;
 
+  @override
   R visitHideCombinator(HideCombinator node) => null;
 
+  @override
   R visitIfStatement(IfStatement node) => null;
 
+  @override
   R visitImplementsClause(ImplementsClause node) => null;
 
+  @override
   R visitImportDirective(ImportDirective node) => null;
 
+  @override
   R visitIndexExpression(IndexExpression node) => null;
 
+  @override
   R visitInstanceCreationExpression(InstanceCreationExpression node) => null;
 
+  @override
   R visitIntegerLiteral(IntegerLiteral node) => null;
 
+  @override
   R visitInterpolationExpression(InterpolationExpression node) => null;
 
+  @override
   R visitInterpolationString(InterpolationString node) => null;
 
+  @override
   R visitIsExpression(IsExpression node) => null;
 
+  @override
   R visitLabel(Label node) => null;
 
+  @override
   R visitLabeledStatement(LabeledStatement node) => null;
 
+  @override
   R visitLibraryDirective(LibraryDirective node) => null;
 
+  @override
   R visitLibraryIdentifier(LibraryIdentifier node) => null;
 
+  @override
   R visitListLiteral(ListLiteral node) => null;
 
+  @override
   R visitMapLiteral(MapLiteral node) => null;
 
+  @override
   R visitMapLiteralEntry(MapLiteralEntry node) => null;
 
+  @override
   R visitMethodDeclaration(MethodDeclaration node) => null;
 
+  @override
   R visitMethodInvocation(MethodInvocation node) => null;
 
+  @override
   R visitNamedExpression(NamedExpression node) => null;
 
+  @override
   R visitNativeClause(NativeClause node) => null;
 
+  @override
   R visitNativeFunctionBody(NativeFunctionBody node) => null;
 
+  @override
   R visitNullLiteral(NullLiteral node) => null;
 
+  @override
   R visitParenthesizedExpression(ParenthesizedExpression node) => null;
 
+  @override
   R visitPartDirective(PartDirective node) => null;
 
+  @override
   R visitPartOfDirective(PartOfDirective node) => null;
 
+  @override
   R visitPostfixExpression(PostfixExpression node) => null;
 
+  @override
   R visitPrefixedIdentifier(PrefixedIdentifier node) => null;
 
+  @override
   R visitPrefixExpression(PrefixExpression node) => null;
 
+  @override
   R visitPropertyAccess(PropertyAccess node) => null;
 
+  @override
   R visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) => null;
 
+  @override
   R visitRethrowExpression(RethrowExpression node) => null;
 
+  @override
   R visitReturnStatement(ReturnStatement node) => null;
 
+  @override
   R visitScriptTag(ScriptTag node) => null;
 
+  @override
   R visitShowCombinator(ShowCombinator node) => null;
 
+  @override
   R visitSimpleFormalParameter(SimpleFormalParameter node) => null;
 
+  @override
   R visitSimpleIdentifier(SimpleIdentifier node) => null;
 
+  @override
   R visitSimpleStringLiteral(SimpleStringLiteral node) => null;
 
+  @override
   R visitStringInterpolation(StringInterpolation node) => null;
 
+  @override
   R visitSuperConstructorInvocation(SuperConstructorInvocation node) => null;
 
+  @override
   R visitSuperExpression(SuperExpression node) => null;
 
+  @override
   R visitSwitchCase(SwitchCase node) => null;
 
+  @override
   R visitSwitchDefault(SwitchDefault node) => null;
 
+  @override
   R visitSwitchStatement(SwitchStatement node) => null;
 
+  @override
   R visitSymbolLiteral(SymbolLiteral node) => null;
 
+  @override
   R visitThisExpression(ThisExpression node) => null;
 
+  @override
   R visitThrowExpression(ThrowExpression node) => null;
 
+  @override
   R visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => null;
 
+  @override
   R visitTryStatement(TryStatement node) => null;
 
+  @override
   R visitTypeArgumentList(TypeArgumentList node) => null;
 
+  @override
   R visitTypeName(TypeName node) => null;
 
+  @override
   R visitTypeParameter(TypeParameter node) => null;
 
+  @override
   R visitTypeParameterList(TypeParameterList node) => null;
 
+  @override
   R visitVariableDeclaration(VariableDeclaration node) => null;
 
+  @override
   R visitVariableDeclarationList(VariableDeclarationList node) => null;
 
+  @override
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => null;
 
+  @override
   R visitWhileStatement(WhileStatement node) => null;
 
+  @override
   R visitWithClause(WithClause node) => null;
 }
 
 /**
  * Instances of the class `ToSourceVisitor` write a source representation of a visited AST
  * node (and all of it's children) to a writer.
  */
 class ToSourceVisitor implements AstVisitor<Object> {
   /**
    * The writer to which the source is to be written.
    */
   PrintWriter _writer;
 
   /**
    * Initialize a newly created visitor to write source code representing the visited nodes to the
    * given writer.
    *
    * @param writer the writer to which the source is to be written
    */
   ToSourceVisitor(PrintWriter writer) {
     this._writer = writer;
   }
 
+  @override
   Object visitAdjacentStrings(AdjacentStrings node) {
     _visitNodeListWithSeparator(node.strings, " ");
     return null;
   }
 
+  @override
   Object visitAnnotation(Annotation node) {
     _writer.print('@');
     _visitNode(node.name);
     _visitNodeWithPrefix(".", node.constructorName);
     _visitNode(node.arguments);
     return null;
   }
 
+  @override
   Object visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     _writer.print('?');
     _visitNode(node.identifier);
     return null;
   }
 
+  @override
   Object visitArgumentList(ArgumentList node) {
     _writer.print('(');
     _visitNodeListWithSeparator(node.arguments, ", ");
     _writer.print(')');
     return null;
   }
 
+  @override
   Object visitAsExpression(AsExpression node) {
     _visitNode(node.expression);
     _writer.print(" as ");
     _visitNode(node.type);
     return null;
   }
 
+  @override
   Object visitAssertStatement(AssertStatement node) {
     _writer.print("assert (");
     _visitNode(node.condition);
     _writer.print(");");
     return null;
   }
 
+  @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     _visitNode(node.leftHandSide);
     _writer.print(' ');
     _writer.print(node.operator.lexeme);
     _writer.print(' ');
     _visitNode(node.rightHandSide);
     return null;
   }
 
+  @override
   Object visitBinaryExpression(BinaryExpression node) {
     _visitNode(node.leftOperand);
     _writer.print(' ');
     _writer.print(node.operator.lexeme);
     _writer.print(' ');
     _visitNode(node.rightOperand);
     return null;
   }
 
+  @override
   Object visitBlock(Block node) {
     _writer.print('{');
     _visitNodeListWithSeparator(node.statements, " ");
     _writer.print('}');
     return null;
   }
 
+  @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     _visitNode(node.block);
     return null;
   }
 
+  @override
   Object visitBooleanLiteral(BooleanLiteral node) {
     _writer.print(node.literal.lexeme);
     return null;
   }
 
+  @override
   Object visitBreakStatement(BreakStatement node) {
     _writer.print("break");
     _visitNodeWithPrefix(" ", node.label);
     _writer.print(";");
     return null;
   }
 
+  @override
   Object visitCascadeExpression(CascadeExpression node) {
     _visitNode(node.target);
     _visitNodeList(node.cascadeSections);
     return null;
   }
 
+  @override
   Object visitCatchClause(CatchClause node) {
     _visitNodeWithPrefix("on ", node.exceptionType);
     if (node.catchKeyword != null) {
       if (node.exceptionType != null) {
         _writer.print(' ');
       }
       _writer.print("catch (");
       _visitNode(node.exceptionParameter);
       _visitNodeWithPrefix(", ", node.stackTraceParameter);
       _writer.print(") ");
     } else {
       _writer.print(" ");
     }
     _visitNode(node.body);
     return null;
   }
 
+  @override
   Object visitClassDeclaration(ClassDeclaration node) {
     _visitTokenWithSuffix(node.abstractKeyword, " ");
     _writer.print("class ");
     _visitNode(node.name);
     _visitNode(node.typeParameters);
     _visitNodeWithPrefix(" ", node.extendsClause);
     _visitNodeWithPrefix(" ", node.withClause);
     _visitNodeWithPrefix(" ", node.implementsClause);
     _writer.print(" {");
     _visitNodeListWithSeparator(node.members, " ");
     _writer.print("}");
     return null;
   }
 
+  @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     if (node.abstractKeyword != null) {
       _writer.print("abstract ");
     }
     _writer.print("class ");
     _visitNode(node.name);
     _visitNode(node.typeParameters);
     _writer.print(" = ");
     _visitNode(node.superclass);
     _visitNodeWithPrefix(" ", node.withClause);
     _visitNodeWithPrefix(" ", node.implementsClause);
     _writer.print(";");
     return null;
   }
 
+  @override
   Object visitComment(Comment node) => null;
 
+  @override
   Object visitCommentReference(CommentReference node) => null;
 
+  @override
   Object visitCompilationUnit(CompilationUnit node) {
     ScriptTag scriptTag = node.scriptTag;
     NodeList<Directive> directives = node.directives;
     _visitNode(scriptTag);
     String prefix = scriptTag == null ? "" : " ";
     _visitNodeListWithSeparatorAndPrefix(prefix, directives, " ");
     prefix = scriptTag == null && directives.isEmpty ? "" : " ";
     _visitNodeListWithSeparatorAndPrefix(prefix, node.declarations, " ");
     return null;
   }
 
+  @override
   Object visitConditionalExpression(ConditionalExpression node) {
     _visitNode(node.condition);
     _writer.print(" ? ");
     _visitNode(node.thenExpression);
     _writer.print(" : ");
     _visitNode(node.elseExpression);
     return null;
   }
 
+  @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     _visitTokenWithSuffix(node.externalKeyword, " ");
     _visitTokenWithSuffix(node.constKeyword, " ");
     _visitTokenWithSuffix(node.factoryKeyword, " ");
     _visitNode(node.returnType);
     _visitNodeWithPrefix(".", node.name);
     _visitNode(node.parameters);
     _visitNodeListWithSeparatorAndPrefix(" : ", node.initializers, ", ");
     _visitNodeWithPrefix(" = ", node.redirectedConstructor);
     _visitFunctionWithPrefix(" ", node.body);
     return null;
   }
 
+  @override
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     _visitTokenWithSuffix(node.keyword, ".");
     _visitNode(node.fieldName);
     _writer.print(" = ");
     _visitNode(node.expression);
     return null;
   }
 
+  @override
   Object visitConstructorName(ConstructorName node) {
     _visitNode(node.type);
     _visitNodeWithPrefix(".", node.name);
     return null;
   }
 
+  @override
   Object visitContinueStatement(ContinueStatement node) {
     _writer.print("continue");
     _visitNodeWithPrefix(" ", node.label);
     _writer.print(";");
     return null;
   }
 
+  @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     _visitTokenWithSuffix(node.keyword, " ");
     _visitNodeWithSuffix(node.type, " ");
     _visitNode(node.identifier);
     return null;
   }
 
+  @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     _visitNode(node.parameter);
     if (node.separator != null) {
       _writer.print(" ");
       _writer.print(node.separator.lexeme);
       _visitNodeWithPrefix(" ", node.defaultValue);
     }
     return null;
   }
 
+  @override
   Object visitDoStatement(DoStatement node) {
     _writer.print("do ");
     _visitNode(node.body);
     _writer.print(" while (");
     _visitNode(node.condition);
     _writer.print(");");
     return null;
   }
 
+  @override
   Object visitDoubleLiteral(DoubleLiteral node) {
     _writer.print(node.literal.lexeme);
     return null;
   }
 
+  @override
   Object visitEmptyFunctionBody(EmptyFunctionBody node) {
     _writer.print(';');
     return null;
   }
 
+  @override
   Object visitEmptyStatement(EmptyStatement node) {
     _writer.print(';');
     return null;
   }
 
+  @override
   Object visitExportDirective(ExportDirective node) {
     _writer.print("export ");
     _visitNode(node.uri);
     _visitNodeListWithSeparatorAndPrefix(" ", node.combinators, " ");
     _writer.print(';');
     return null;
   }
 
+  @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     _writer.print("=> ");
     _visitNode(node.expression);
     if (node.semicolon != null) {
       _writer.print(';');
     }
     return null;
   }
 
+  @override
   Object visitExpressionStatement(ExpressionStatement node) {
     _visitNode(node.expression);
     _writer.print(';');
     return null;
   }
 
+  @override
   Object visitExtendsClause(ExtendsClause node) {
     _writer.print("extends ");
     _visitNode(node.superclass);
     return null;
   }
 
+  @override
   Object visitFieldDeclaration(FieldDeclaration node) {
     _visitTokenWithSuffix(node.staticKeyword, " ");
     _visitNode(node.fields);
     _writer.print(";");
     return null;
   }
 
+  @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     _visitTokenWithSuffix(node.keyword, " ");
     _visitNodeWithSuffix(node.type, " ");
     _writer.print("this.");
     _visitNode(node.identifier);
     _visitNode(node.parameters);
     return null;
   }
 
+  @override
   Object visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     _writer.print("for (");
     if (loopVariable == null) {
       _visitNode(node.identifier);
     } else {
       _visitNode(loopVariable);
     }
     _writer.print(" in ");
     _visitNode(node.iterator);
     _writer.print(") ");
     _visitNode(node.body);
     return null;
   }
 
+  @override
   Object visitFormalParameterList(FormalParameterList node) {
     String groupEnd = null;
     _writer.print('(');
     NodeList<FormalParameter> parameters = node.parameters;
     int size = parameters.length;
     for (int i = 0; i < size; i++) {
       FormalParameter parameter = parameters[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('[');
         }
       }
       parameter.accept(this);
     }
     if (groupEnd != null) {
       _writer.print(groupEnd);
     }
     _writer.print(')');
     return null;
   }
 
+  @override
   Object visitForStatement(ForStatement node) {
     Expression initialization = node.initialization;
     _writer.print("for (");
     if (initialization != null) {
       _visitNode(initialization);
     } else {
       _visitNode(node.variables);
     }
     _writer.print(";");
     _visitNodeWithPrefix(" ", node.condition);
     _writer.print(";");
     _visitNodeListWithSeparatorAndPrefix(" ", node.updaters, ", ");
     _writer.print(") ");
     _visitNode(node.body);
     return null;
   }
 
+  @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     _visitNodeWithSuffix(node.returnType, " ");
     _visitTokenWithSuffix(node.propertyKeyword, " ");
     _visitNode(node.name);
     _visitNode(node.functionExpression);
     return null;
   }
 
+  @override
   Object visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     _visitNode(node.functionDeclaration);
     _writer.print(';');
     return null;
   }
 
+  @override
   Object visitFunctionExpression(FunctionExpression node) {
     _visitNode(node.parameters);
     _writer.print(' ');
     _visitNode(node.body);
     return null;
   }
 
+  @override
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     _visitNode(node.function);
     _visitNode(node.argumentList);
     return null;
   }
 
+  @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     _writer.print("typedef ");
     _visitNodeWithSuffix(node.returnType, " ");
     _visitNode(node.name);
     _visitNode(node.typeParameters);
     _visitNode(node.parameters);
     _writer.print(";");
     return null;
   }
 
+  @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     _visitNodeWithSuffix(node.returnType, " ");
     _visitNode(node.identifier);
     _visitNode(node.parameters);
     return null;
   }
 
+  @override
   Object visitHideCombinator(HideCombinator node) {
     _writer.print("hide ");
     _visitNodeListWithSeparator(node.hiddenNames, ", ");
     return null;
   }
 
+  @override
   Object visitIfStatement(IfStatement node) {
     _writer.print("if (");
     _visitNode(node.condition);
     _writer.print(") ");
     _visitNode(node.thenStatement);
     _visitNodeWithPrefix(" else ", node.elseStatement);
     return null;
   }
 
+  @override
   Object visitImplementsClause(ImplementsClause node) {
     _writer.print("implements ");
     _visitNodeListWithSeparator(node.interfaces, ", ");
     return null;
   }
 
+  @override
   Object visitImportDirective(ImportDirective node) {
     _writer.print("import ");
     _visitNode(node.uri);
     _visitNodeWithPrefix(" as ", node.prefix);
     _visitNodeListWithSeparatorAndPrefix(" ", node.combinators, " ");
     _writer.print(';');
     return null;
   }
 
+  @override
   Object visitIndexExpression(IndexExpression node) {
     if (node.isCascaded) {
       _writer.print("..");
     } else {
       _visitNode(node.target);
     }
     _writer.print('[');
     _visitNode(node.index);
     _writer.print(']');
     return null;
   }
 
+  @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     _visitTokenWithSuffix(node.keyword, " ");
     _visitNode(node.constructorName);
     _visitNode(node.argumentList);
     return null;
   }
 
+  @override
   Object visitIntegerLiteral(IntegerLiteral node) {
     _writer.print(node.literal.lexeme);
     return null;
   }
 
+  @override
   Object visitInterpolationExpression(InterpolationExpression node) {
     if (node.rightBracket != null) {
       _writer.print("\${");
       _visitNode(node.expression);
       _writer.print("}");
     } else {
       _writer.print("\$");
       _visitNode(node.expression);
     }
     return null;
   }
 
+  @override
   Object visitInterpolationString(InterpolationString node) {
     _writer.print(node.contents.lexeme);
     return null;
   }
 
+  @override
   Object visitIsExpression(IsExpression node) {
     _visitNode(node.expression);
     if (node.notOperator == null) {
       _writer.print(" is ");
     } else {
       _writer.print(" is! ");
     }
     _visitNode(node.type);
     return null;
   }
 
+  @override
   Object visitLabel(Label node) {
     _visitNode(node.label);
     _writer.print(":");
     return null;
   }
 
+  @override
   Object visitLabeledStatement(LabeledStatement node) {
     _visitNodeListWithSeparatorAndSuffix(node.labels, " ", " ");
     _visitNode(node.statement);
     return null;
   }
 
+  @override
   Object visitLibraryDirective(LibraryDirective node) {
     _writer.print("library ");
     _visitNode(node.name);
     _writer.print(';');
     return null;
   }
 
+  @override
   Object visitLibraryIdentifier(LibraryIdentifier node) {
     _writer.print(node.name);
     return null;
   }
 
+  @override
   Object visitListLiteral(ListLiteral node) {
     if (node.constKeyword != null) {
       _writer.print(node.constKeyword.lexeme);
       _writer.print(' ');
     }
     _visitNodeWithSuffix(node.typeArguments, " ");
     _writer.print("[");
     _visitNodeListWithSeparator(node.elements, ", ");
     _writer.print("]");
     return null;
   }
 
+  @override
   Object visitMapLiteral(MapLiteral node) {
     if (node.constKeyword != null) {
       _writer.print(node.constKeyword.lexeme);
       _writer.print(' ');
     }
     _visitNodeWithSuffix(node.typeArguments, " ");
     _writer.print("{");
     _visitNodeListWithSeparator(node.entries, ", ");
     _writer.print("}");
     return null;
   }
 
+  @override
   Object visitMapLiteralEntry(MapLiteralEntry node) {
     _visitNode(node.key);
     _writer.print(" : ");
     _visitNode(node.value);
     return null;
   }
 
+  @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     _visitTokenWithSuffix(node.externalKeyword, " ");
     _visitTokenWithSuffix(node.modifierKeyword, " ");
     _visitNodeWithSuffix(node.returnType, " ");
     _visitTokenWithSuffix(node.propertyKeyword, " ");
     _visitTokenWithSuffix(node.operatorKeyword, " ");
     _visitNode(node.name);
     if (!node.isGetter) {
       _visitNode(node.parameters);
     }
     _visitFunctionWithPrefix(" ", node.body);
     return null;
   }
 
+  @override
   Object visitMethodInvocation(MethodInvocation node) {
     if (node.isCascaded) {
       _writer.print("..");
     } else {
       _visitNodeWithSuffix(node.target, ".");
     }
     _visitNode(node.methodName);
     _visitNode(node.argumentList);
     return null;
   }
 
+  @override
   Object visitNamedExpression(NamedExpression node) {
     _visitNode(node.name);
     _visitNodeWithPrefix(" ", node.expression);
     return null;
   }
 
+  @override
   Object visitNativeClause(NativeClause node) {
     _writer.print("native ");
     _visitNode(node.name);
     return null;
   }
 
+  @override
   Object visitNativeFunctionBody(NativeFunctionBody node) {
     _writer.print("native ");
     _visitNode(node.stringLiteral);
     _writer.print(';');
     return null;
   }
 
+  @override
   Object visitNullLiteral(NullLiteral node) {
     _writer.print("null");
     return null;
   }
 
+  @override
   Object visitParenthesizedExpression(ParenthesizedExpression node) {
     _writer.print('(');
     _visitNode(node.expression);
     _writer.print(')');
     return null;
   }
 
+  @override
   Object visitPartDirective(PartDirective node) {
     _writer.print("part ");
     _visitNode(node.uri);
     _writer.print(';');
     return null;
   }
 
+  @override
   Object visitPartOfDirective(PartOfDirective node) {
     _writer.print("part of ");
     _visitNode(node.libraryName);
     _writer.print(';');
     return null;
   }
 
+  @override
   Object visitPostfixExpression(PostfixExpression node) {
     _visitNode(node.operand);
     _writer.print(node.operator.lexeme);
     return null;
   }
 
+  @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     _visitNode(node.prefix);
     _writer.print('.');
     _visitNode(node.identifier);
     return null;
   }
 
+  @override
   Object visitPrefixExpression(PrefixExpression node) {
     _writer.print(node.operator.lexeme);
     _visitNode(node.operand);
     return null;
   }
 
+  @override
   Object visitPropertyAccess(PropertyAccess node) {
     if (node.isCascaded) {
       _writer.print("..");
     } else {
       _visitNode(node.target);
       _writer.print('.');
     }
     _visitNode(node.propertyName);
     return null;
   }
 
+  @override
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     _writer.print("this");
     _visitNodeWithPrefix(".", node.constructorName);
     _visitNode(node.argumentList);
     return null;
   }
 
+  @override
   Object visitRethrowExpression(RethrowExpression node) {
     _writer.print("rethrow");
     return null;
   }
 
+  @override
   Object visitReturnStatement(ReturnStatement node) {
     Expression expression = node.expression;
     if (expression == null) {
       _writer.print("return;");
     } else {
       _writer.print("return ");
       expression.accept(this);
       _writer.print(";");
     }
     return null;
   }
 
+  @override
   Object visitScriptTag(ScriptTag node) {
     _writer.print(node.scriptTag.lexeme);
     return null;
   }
 
+  @override
   Object visitShowCombinator(ShowCombinator node) {
     _writer.print("show ");
     _visitNodeListWithSeparator(node.shownNames, ", ");
     return null;
   }
 
+  @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     _visitTokenWithSuffix(node.keyword, " ");
     _visitNodeWithSuffix(node.type, " ");
     _visitNode(node.identifier);
     return null;
   }
 
+  @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     _writer.print(node.token.lexeme);
     return null;
   }
 
+  @override
   Object visitSimpleStringLiteral(SimpleStringLiteral node) {
     _writer.print(node.literal.lexeme);
     return null;
   }
 
+  @override
   Object visitStringInterpolation(StringInterpolation node) {
     _visitNodeList(node.elements);
     return null;
   }
 
+  @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     _writer.print("super");
     _visitNodeWithPrefix(".", node.constructorName);
     _visitNode(node.argumentList);
     return null;
   }
 
+  @override
   Object visitSuperExpression(SuperExpression node) {
     _writer.print("super");
     return null;
   }
 
+  @override
   Object visitSwitchCase(SwitchCase node) {
     _visitNodeListWithSeparatorAndSuffix(node.labels, " ", " ");
     _writer.print("case ");
     _visitNode(node.expression);
     _writer.print(": ");
     _visitNodeListWithSeparator(node.statements, " ");
     return null;
   }
 
+  @override
   Object visitSwitchDefault(SwitchDefault node) {
     _visitNodeListWithSeparatorAndSuffix(node.labels, " ", " ");
     _writer.print("default: ");
     _visitNodeListWithSeparator(node.statements, " ");
     return null;
   }
 
+  @override
   Object visitSwitchStatement(SwitchStatement node) {
     _writer.print("switch (");
     _visitNode(node.expression);
     _writer.print(") {");
     _visitNodeListWithSeparator(node.members, " ");
     _writer.print("}");
     return null;
   }
 
+  @override
   Object visitSymbolLiteral(SymbolLiteral node) {
     _writer.print("#");
     List<Token> components = node.components;
     for (int i = 0; i < components.length; i++) {
       if (i > 0) {
         _writer.print(".");
       }
       _writer.print(components[i].lexeme);
     }
     return null;
   }
 
+  @override
   Object visitThisExpression(ThisExpression node) {
     _writer.print("this");
     return null;
   }
 
+  @override
   Object visitThrowExpression(ThrowExpression node) {
     _writer.print("throw ");
     _visitNode(node.expression);
     return null;
   }
 
+  @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _visitNodeWithSuffix(node.variables, ";");
     return null;
   }
 
+  @override
   Object visitTryStatement(TryStatement node) {
     _writer.print("try ");
     _visitNode(node.body);
     _visitNodeListWithSeparatorAndPrefix(" ", node.catchClauses, " ");
     _visitNodeWithPrefix(" finally ", node.finallyBlock);
     return null;
   }
 
+  @override
   Object visitTypeArgumentList(TypeArgumentList node) {
     _writer.print('<');
     _visitNodeListWithSeparator(node.arguments, ", ");
     _writer.print('>');
     return null;
   }
 
+  @override
   Object visitTypeName(TypeName node) {
     _visitNode(node.name);
     _visitNode(node.typeArguments);
     return null;
   }
 
+  @override
   Object visitTypeParameter(TypeParameter node) {
     _visitNode(node.name);
     _visitNodeWithPrefix(" extends ", node.bound);
     return null;
   }
 
+  @override
   Object visitTypeParameterList(TypeParameterList node) {
     _writer.print('<');
     _visitNodeListWithSeparator(node.typeParameters, ", ");
     _writer.print('>');
     return null;
   }
 
+  @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     _visitNode(node.name);
     _visitNodeWithPrefix(" = ", node.initializer);
     return null;
   }
 
+  @override
   Object visitVariableDeclarationList(VariableDeclarationList node) {
     _visitTokenWithSuffix(node.keyword, " ");
     _visitNodeWithSuffix(node.type, " ");
     _visitNodeListWithSeparator(node.variables, ", ");
     return null;
   }
 
+  @override
   Object visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     _visitNode(node.variables);
     _writer.print(";");
     return null;
   }
 
+  @override
   Object visitWhileStatement(WhileStatement node) {
     _writer.print("while (");
     _visitNode(node.condition);
     _writer.print(") ");
     _visitNode(node.body);
     return null;
   }
 
+  @override
   Object visitWithClause(WithClause node) {
     _writer.print("with ");
     _visitNodeListWithSeparator(node.mixinTypes, ", ");
     return null;
   }
 
   /**
    * Visit the given function body, printing the prefix before if given body is not empty.
    *
    * @param prefix the prefix to be printed if there is a node to visit
@@ skipping 133 matching lines @@
  * Instances of the class `UnifyingAstVisitor` implement an AST visitor that will recursively
  * visit all of the nodes in an AST structure (like instances of the class
  * [RecursiveAstVisitor]). In addition, every node will also be visited by using a single
  * unified [visitNode] method.
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or
  * explicitly invoke the more general [visitNode] method. Failure to do so will
  * cause the children of the visited node to not be visited.
  */
 class UnifyingAstVisitor<R> implements AstVisitor<R> {
+  @override
   R visitAdjacentStrings(AdjacentStrings node) => visitNode(node);
 
+  @override
   R visitAnnotation(Annotation node) => visitNode(node);
 
+  @override
   R visitArgumentDefinitionTest(ArgumentDefinitionTest node) => visitNode(node);
 
+  @override
   R visitArgumentList(ArgumentList node) => visitNode(node);
 
+  @override
   R visitAsExpression(AsExpression node) => visitNode(node);
 
+  @override
   R visitAssertStatement(AssertStatement node) => visitNode(node);
 
+  @override
   R visitAssignmentExpression(AssignmentExpression node) => visitNode(node);
 
+  @override
   R visitBinaryExpression(BinaryExpression node) => visitNode(node);
 
+  @override
   R visitBlock(Block node) => visitNode(node);
 
+  @override
   R visitBlockFunctionBody(BlockFunctionBody node) => visitNode(node);
 
+  @override
   R visitBooleanLiteral(BooleanLiteral node) => visitNode(node);
 
+  @override
   R visitBreakStatement(BreakStatement node) => visitNode(node);
 
+  @override
   R visitCascadeExpression(CascadeExpression node) => visitNode(node);
 
+  @override
   R visitCatchClause(CatchClause node) => visitNode(node);
 
+  @override
   R visitClassDeclaration(ClassDeclaration node) => visitNode(node);
 
+  @override
   R visitClassTypeAlias(ClassTypeAlias node) => visitNode(node);
 
+  @override
   R visitComment(Comment node) => visitNode(node);
 
+  @override
   R visitCommentReference(CommentReference node) => visitNode(node);
 
+  @override
   R visitCompilationUnit(CompilationUnit node) => visitNode(node);
 
+  @override
   R visitConditionalExpression(ConditionalExpression node) => visitNode(node);
 
+  @override
   R visitConstructorDeclaration(ConstructorDeclaration node) => visitNode(node);
 
+  @override
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node) => visitNode(node);
 
+  @override
   R visitConstructorName(ConstructorName node) => visitNode(node);
 
+  @override
   R visitContinueStatement(ContinueStatement node) => visitNode(node);
 
+  @override
   R visitDeclaredIdentifier(DeclaredIdentifier node) => visitNode(node);
 
+  @override
   R visitDefaultFormalParameter(DefaultFormalParameter node) => visitNode(node);
 
+  @override
   R visitDoStatement(DoStatement node) => visitNode(node);
 
+  @override
   R visitDoubleLiteral(DoubleLiteral node) => visitNode(node);
 
+  @override
   R visitEmptyFunctionBody(EmptyFunctionBody node) => visitNode(node);
 
+  @override
   R visitEmptyStatement(EmptyStatement node) => visitNode(node);
 
+  @override
   R visitExportDirective(ExportDirective node) => visitNode(node);
 
+  @override
   R visitExpressionFunctionBody(ExpressionFunctionBody node) => visitNode(node);
 
+  @override
   R visitExpressionStatement(ExpressionStatement node) => visitNode(node);
 
+  @override
   R visitExtendsClause(ExtendsClause node) => visitNode(node);
 
+  @override
   R visitFieldDeclaration(FieldDeclaration node) => visitNode(node);
 
+  @override
   R visitFieldFormalParameter(FieldFormalParameter node) => visitNode(node);
 
+  @override
   R visitForEachStatement(ForEachStatement node) => visitNode(node);
 
+  @override
   R visitFormalParameterList(FormalParameterList node) => visitNode(node);
 
+  @override
   R visitForStatement(ForStatement node) => visitNode(node);
 
+  @override
   R visitFunctionDeclaration(FunctionDeclaration node) => visitNode(node);
 
+  @override
   R visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => visitNode(node);
 
+  @override
   R visitFunctionExpression(FunctionExpression node) => visitNode(node);
 
+  @override
   R visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => visitNode(node);
 
+  @override
   R visitFunctionTypeAlias(FunctionTypeAlias node) => visitNode(node);
 
+  @override
   R visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => visitNode(node);
 
+  @override
   R visitHideCombinator(HideCombinator node) => visitNode(node);
 
+  @override
   R visitIfStatement(IfStatement node) => visitNode(node);
 
+  @override
   R visitImplementsClause(ImplementsClause node) => visitNode(node);
 
+  @override
   R visitImportDirective(ImportDirective node) => visitNode(node);
 
+  @override
   R visitIndexExpression(IndexExpression node) => visitNode(node);
 
+  @override
   R visitInstanceCreationExpression(InstanceCreationExpression node) => visitNode(node);
 
+  @override
   R visitIntegerLiteral(IntegerLiteral node) => visitNode(node);
 
+  @override
   R visitInterpolationExpression(InterpolationExpression node) => visitNode(node);
 
+  @override
   R visitInterpolationString(InterpolationString node) => visitNode(node);
 
+  @override
   R visitIsExpression(IsExpression node) => visitNode(node);
 
+  @override
   R visitLabel(Label node) => visitNode(node);
 
+  @override
   R visitLabeledStatement(LabeledStatement node) => visitNode(node);
 
+  @override
   R visitLibraryDirective(LibraryDirective node) => visitNode(node);
 
+  @override
   R visitLibraryIdentifier(LibraryIdentifier node) => visitNode(node);
 
+  @override
   R visitListLiteral(ListLiteral node) => visitNode(node);
 
+  @override
   R visitMapLiteral(MapLiteral node) => visitNode(node);
 
+  @override
   R visitMapLiteralEntry(MapLiteralEntry node) => visitNode(node);
 
+  @override
   R visitMethodDeclaration(MethodDeclaration node) => visitNode(node);
 
+  @override
   R visitMethodInvocation(MethodInvocation node) => visitNode(node);
 
+  @override
   R visitNamedExpression(NamedExpression node) => visitNode(node);
 
+  @override
   R visitNativeClause(NativeClause node) => visitNode(node);
 
+  @override
   R visitNativeFunctionBody(NativeFunctionBody node) => visitNode(node);
 
   R visitNode(AstNode node) {
     node.visitChildren(this);
     return null;
   }
 
+  @override
   R visitNullLiteral(NullLiteral node) => visitNode(node);
 
+  @override
   R visitParenthesizedExpression(ParenthesizedExpression node) => visitNode(node);
 
+  @override
   R visitPartDirective(PartDirective node) => visitNode(node);
 
+  @override
   R visitPartOfDirective(PartOfDirective node) => visitNode(node);
 
+  @override
   R visitPostfixExpression(PostfixExpression node) => visitNode(node);
 
+  @override
   R visitPrefixedIdentifier(PrefixedIdentifier node) => visitNode(node);
 
+  @override
   R visitPrefixExpression(PrefixExpression node) => visitNode(node);
 
+  @override
   R visitPropertyAccess(PropertyAccess node) => visitNode(node);
 
+  @override
   R visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) => visitNode(node);
 
+  @override
   R visitRethrowExpression(RethrowExpression node) => visitNode(node);
 
+  @override
   R visitReturnStatement(ReturnStatement node) => visitNode(node);
 
+  @override
   R visitScriptTag(ScriptTag scriptTag) => visitNode(scriptTag);
 
+  @override
   R visitShowCombinator(ShowCombinator node) => visitNode(node);
 
+  @override
   R visitSimpleFormalParameter(SimpleFormalParameter node) => visitNode(node);
 
+  @override
   R visitSimpleIdentifier(SimpleIdentifier node) => visitNode(node);
 
+  @override
   R visitSimpleStringLiteral(SimpleStringLiteral node) => visitNode(node);
 
+  @override
   R visitStringInterpolation(StringInterpolation node) => visitNode(node);
 
+  @override
   R visitSuperConstructorInvocation(SuperConstructorInvocation node) => visitNode(node);
 
+  @override
   R visitSuperExpression(SuperExpression node) => visitNode(node);
 
+  @override
   R visitSwitchCase(SwitchCase node) => visitNode(node);
 
+  @override
   R visitSwitchDefault(SwitchDefault node) => visitNode(node);
 
+  @override
   R visitSwitchStatement(SwitchStatement node) => visitNode(node);
 
+  @override
   R visitSymbolLiteral(SymbolLiteral node) => visitNode(node);
 
+  @override
   R visitThisExpression(ThisExpression node) => visitNode(node);
 
+  @override
   R visitThrowExpression(ThrowExpression node) => visitNode(node);
 
+  @override
   R visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => visitNode(node);
 
+  @override
   R visitTryStatement(TryStatement node) => visitNode(node);
 
+  @override
   R visitTypeArgumentList(TypeArgumentList node) => visitNode(node);
 
+  @override
   R visitTypeName(TypeName node) => visitNode(node);
 
+  @override
   R visitTypeParameter(TypeParameter node) => visitNode(node);
 
+  @override
   R visitTypeParameterList(TypeParameterList node) => visitNode(node);
 
+  @override
   R visitVariableDeclaration(VariableDeclaration node) => visitNode(node);
 
+  @override
   R visitVariableDeclarationList(VariableDeclarationList node) => visitNode(node);
 
+  @override
   R visitVariableDeclarationStatement(VariableDeclarationStatement node) => visitNode(node);
 
+  @override
   R visitWhileStatement(WhileStatement node) => visitNode(node);
 
+  @override
   R visitWithClause(WithClause node) => visitNode(node);
 }
 
 /**
  * Instances of the class `AstCloner` implement an object that will clone any AST structure
  * that it visits. The cloner will only clone the structure, it will not preserve any resolution
  * results or properties associated with the nodes.
  */
 class AstCloner implements AstVisitor<AstNode> {
+  @override
   AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings(_cloneNodeList(node.strings));
 
+  @override
   Annotation visitAnnotation(Annotation node) => new Annotation(node.atSign, _cloneNode(node.name), node.period, _cloneNode(node.constructorName), _cloneNode(node.arguments));
 
+  @override
   ArgumentDefinitionTest visitArgumentDefinitionTest(ArgumentDefinitionTest node) => new ArgumentDefinitionTest(node.question, _cloneNode(node.identifier));
 
+  @override
   ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(node.leftParenthesis, _cloneNodeList(node.arguments), node.rightParenthesis);
 
+  @override
   AsExpression visitAsExpression(AsExpression node) => new AsExpression(_cloneNode(node.expression), node.asOperator, _cloneNode(node.type));
 
+  @override
   AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(node.keyword, node.leftParenthesis, _cloneNode(node.condition), node.rightParenthesis, node.semicolon);
 
+  @override
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) => new AssignmentExpression(_cloneNode(node.leftHandSide), node.operator, _cloneNode(node.rightHandSide));
 
+  @override
   BinaryExpression visitBinaryExpression(BinaryExpression node) => new BinaryExpression(_cloneNode(node.leftOperand), node.operator, _cloneNode(node.rightOperand));
 
+  @override
   Block visitBlock(Block node) => new Block(node.leftBracket, _cloneNodeList(node.statements), node.rightBracket);
 
+  @override
   BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody(_cloneNode(node.block));
 
+  @override
   BooleanLiteral visitBooleanLiteral(BooleanLiteral node) => new BooleanLiteral(node.literal, node.value);
 
+  @override
   BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement(node.keyword, _cloneNode(node.label), node.semicolon);
 
+  @override
   CascadeExpression visitCascadeExpression(CascadeExpression node) => new CascadeExpression(_cloneNode(node.target), _cloneNodeList(node.cascadeSections));
 
+  @override
   CatchClause visitCatchClause(CatchClause node) => new CatchClause(node.onKeyword, _cloneNode(node.exceptionType), node.catchKeyword, node.leftParenthesis, _cloneNode(node.exceptionParameter), node.comma, _cloneNode(node.stackTraceParameter), node.rightParenthesis, _cloneNode(node.body));
 
+  @override
   ClassDeclaration visitClassDeclaration(ClassDeclaration node) {
     ClassDeclaration copy = new ClassDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.abstractKeyword, node.classKeyword, _cloneNode(node.name), _cloneNode(node.typeParameters), _cloneNode(node.extendsClause), _cloneNode(node.withClause), _cloneNode(node.implementsClause), node.leftBracket, _cloneNodeList(node.members), node.rightBracket);
     copy.nativeClause = _cloneNode(node.nativeClause);
     return copy;
   }
 
+  @override
   ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => new ClassTypeAlias(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.keyword, _cloneNode(node.name), _cloneNode(node.typeParameters), node.equals, node.abstractKeyword, _cloneNode(node.superclass), _cloneNode(node.withClause), _cloneNode(node.implementsClause), node.semicolon);
 
+  @override
   Comment visitComment(Comment node) {
     if (node.isDocumentation) {
       return Comment.createDocumentationCommentWithReferences(node.tokens, _cloneNodeList(node.references));
     } else if (node.isBlock) {
       return Comment.createBlockComment(node.tokens);
     }
     return Comment.createEndOfLineComment(node.tokens);
   }
 
+  @override
   CommentReference visitCommentReference(CommentReference node) => new CommentReference(node.newKeyword, _cloneNode(node.identifier));
 
+  @override
   CompilationUnit visitCompilationUnit(CompilationUnit node) {
     CompilationUnit clone = new CompilationUnit(node.beginToken, _cloneNode(node.scriptTag), _cloneNodeList(node.directives), _cloneNodeList(node.declarations), node.endToken);
     clone.lineInfo = node.lineInfo;
     return clone;
   }
 
+  @override
   ConditionalExpression visitConditionalExpression(ConditionalExpression node) => new ConditionalExpression(_cloneNode(node.condition), node.question, _cloneNode(node.thenExpression), node.colon, _cloneNode(node.elseExpression));
 
+  @override
   ConstructorDeclaration visitConstructorDeclaration(ConstructorDeclaration node) => new ConstructorDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.externalKeyword, node.constKeyword, node.factoryKeyword, _cloneNode(node.returnType), node.period, _cloneNode(node.name), _cloneNode(node.parameters), node.separator, _cloneNodeList(node.initializers), _cloneNode(node.redirectedConstructor), _cloneNode(node.body));
 
+  @override
   ConstructorFieldInitializer visitConstructorFieldInitializer(ConstructorFieldInitializer node) => new ConstructorFieldInitializer(node.keyword, node.period, _cloneNode(node.fieldName), node.equals, _cloneNode(node.expression));
 
+  @override
   ConstructorName visitConstructorName(ConstructorName node) => new ConstructorName(_cloneNode(node.type), node.period, _cloneNode(node.name));
 
+  @override
   ContinueStatement visitContinueStatement(ContinueStatement node) => new ContinueStatement(node.keyword, _cloneNode(node.label), node.semicolon);
 
+  @override
   DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) => new DeclaredIdentifier(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.keyword, _cloneNode(node.type), _cloneNode(node.identifier));
 
+  @override
   DefaultFormalParameter visitDefaultFormalParameter(DefaultFormalParameter node) => new DefaultFormalParameter(_cloneNode(node.parameter), node.kind, node.separator, _cloneNode(node.defaultValue));
 
+  @override
   DoStatement visitDoStatement(DoStatement node) => new DoStatement(node.doKeyword, _cloneNode(node.body), node.whileKeyword, node.leftParenthesis, _cloneNode(node.condition), node.rightParenthesis, node.semicolon);
 
+  @override
   DoubleLiteral visitDoubleLiteral(DoubleLiteral node) => new DoubleLiteral(node.literal, node.value);
 
+  @override
   EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) => new EmptyFunctionBody(node.semicolon);
 
+  @override
   EmptyStatement visitEmptyStatement(EmptyStatement node) => new EmptyStatement(node.semicolon);
 
+  @override
   ExportDirective visitExportDirective(ExportDirective node) => new ExportDirective(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.keyword, _cloneNode(node.uri), _cloneNodeList(node.combinators), node.semicolon);
 
+  @override
   ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody(node.functionDefinition, _cloneNode(node.expression), node.semicolon);
 
+  @override
   ExpressionStatement visitExpressionStatement(ExpressionStatement node) => new ExpressionStatement(_cloneNode(node.expression), node.semicolon);
 
+  @override
   ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause(node.keyword, _cloneNode(node.superclass));
 
+  @override
   FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => new FieldDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.staticKeyword, _cloneNode(node.fields), node.semicolon);
 
+  @override
   FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => new FieldFormalParameter(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.keyword, _cloneNode(node.type), node.thisToken, node.period, _cloneNode(node.identifier), _cloneNode(node.parameters));
 
+  @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
       return new ForEachStatement.con2(node.forKeyword, node.leftParenthesis, _cloneNode(node.identifier), node.inKeyword, _cloneNode(node.iterator), node.rightParenthesis, _cloneNode(node.body));
     }
     return new ForEachStatement.con1(node.forKeyword, node.leftParenthesis, _cloneNode(loopVariable), node.inKeyword, _cloneNode(node.iterator), node.rightParenthesis, _cloneNode(node.body));
   }
 
+  @override
   FormalParameterList visitFormalParameterList(FormalParameterList node) => new FormalParameterList(node.leftParenthesis, _cloneNodeList(node.parameters), node.leftDelimiter, node.rightDelimiter, node.rightParenthesis);
 
+  @override
   ForStatement visitForStatement(ForStatement node) => new ForStatement(node.forKeyword, node.leftParenthesis, _cloneNode(node.variables), _cloneNode(node.initialization), node.leftSeparator, _cloneNode(node.condition), node.rightSeparator, _cloneNodeList(node.updaters), node.rightParenthesis, _cloneNode(node.body));
 
+  @override
   FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => new FunctionDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.externalKeyword, _cloneNode(node.returnType), node.propertyKeyword, _cloneNode(node.name), _cloneNode(node.functionExpression));
 
+  @override
   FunctionDeclarationStatement visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => new FunctionDeclarationStatement(_cloneNode(node.functionDeclaration));
 
+  @override
   FunctionExpression visitFunctionExpression(FunctionExpression node) => new FunctionExpression(_cloneNode(node.parameters), _cloneNode(node.body));
 
+  @override
   FunctionExpressionInvocation visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => new FunctionExpressionInvocation(_cloneNode(node.function), _cloneNode(node.argumentList));
 
+  @override
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => new FunctionTypeAlias(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.keyword, _cloneNode(node.returnType), _cloneNode(node.name), _cloneNode(node.typeParameters), _cloneNode(node.parameters), node.semicolon);
 
+  @override
   FunctionTypedFormalParameter visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _cloneNode(node.returnType), _cloneNode(node.identifier), _cloneNode(node.parameters));
 
+  @override
   HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator(node.keyword, _cloneNodeList(node.hiddenNames));
 
+  @override
   IfStatement visitIfStatement(IfStatement node) => new IfStatement(node.ifKeyword, node.leftParenthesis, _cloneNode(node.condition), node.rightParenthesis, _cloneNode(node.thenStatement), node.elseKeyword, _cloneNode(node.elseStatement));
 
+  @override
   ImplementsClause visitImplementsClause(ImplementsClause node) => new ImplementsClause(node.keyword, _cloneNodeList(node.interfaces));
 
+  @override
   ImportDirective visitImportDirective(ImportDirective node) => new ImportDirective(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.keyword, _cloneNode(node.uri), node.asToken, _cloneNode(node.prefix), _cloneNodeList(node.combinators), node.semicolon);
 
+  @override
   IndexExpression visitIndexExpression(IndexExpression node) {
     Token period = node.period;
     if (period == null) {
       return new IndexExpression.forTarget(_cloneNode(node.target), node.leftBracket, _cloneNode(node.index), node.rightBracket);
     } else {
       return new IndexExpression.forCascade(period, node.leftBracket, _cloneNode(node.index), node.rightBracket);
     }
   }
 
+  @override
   InstanceCreationExpression visitInstanceCreationExpression(InstanceCreationExpression node) => new InstanceCreationExpression(node.keyword, _cloneNode(node.constructorName), _cloneNode(node.argumentList));
 
+  @override
   IntegerLiteral visitIntegerLiteral(IntegerLiteral node) => new IntegerLiteral(node.literal, node.value);
 
+  @override
   InterpolationExpression visitInterpolationExpression(InterpolationExpression node) => new InterpolationExpression(node.leftBracket, _cloneNode(node.expression), node.rightBracket);
 
+  @override
   InterpolationString visitInterpolationString(InterpolationString node) => new InterpolationString(node.contents, node.value);
 
+  @override
   IsExpression visitIsExpression(IsExpression node) => new IsExpression(_cloneNode(node.expression), node.isOperator, node.notOperator, _cloneNode(node.type));
 
+  @override
   Label visitLabel(Label node) => new Label(_cloneNode(node.label), node.colon);
 
+  @override
   LabeledStatement visitLabeledStatement(LabeledStatement node) => new LabeledStatement(_cloneNodeList(node.labels), _cloneNode(node.statement));
 
+  @override
   LibraryDirective visitLibraryDirective(LibraryDirective node) => new LibraryDirective(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.libraryToken, _cloneNode(node.name), node.semicolon);
 
+  @override
   LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) => new LibraryIdentifier(_cloneNodeList(node.components));
 
+  @override
   ListLiteral visitListLiteral(ListLiteral node) => new ListLiteral(node.constKeyword, _cloneNode(node.typeArguments), node.leftBracket, _cloneNodeList(node.elements), node.rightBracket);
 
+  @override
   MapLiteral visitMapLiteral(MapLiteral node) => new MapLiteral(node.constKeyword, _cloneNode(node.typeArguments), node.leftBracket, _cloneNodeList(node.entries), node.rightBracket);
 
+  @override
   MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) => new MapLiteralEntry(_cloneNode(node.key), node.separator, _cloneNode(node.value));
 
+  @override
   MethodDeclaration visitMethodDeclaration(MethodDeclaration node) => new MethodDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.externalKeyword, node.modifierKeyword, _cloneNode(node.returnType), node.propertyKeyword, node.operatorKeyword, _cloneNode(node.name), _cloneNode(node.parameters), _cloneNode(node.body));
 
+  @override
   MethodInvocation visitMethodInvocation(MethodInvocation node) => new MethodInvocation(_cloneNode(node.target), node.period, _cloneNode(node.methodName), _cloneNode(node.argumentList));
 
+  @override
   NamedExpression visitNamedExpression(NamedExpression node) => new NamedExpression(_cloneNode(node.name), _cloneNode(node.expression));
 
+  @override
   AstNode visitNativeClause(NativeClause node) => new NativeClause(node.keyword, _cloneNode(node.name));
 
+  @override
   NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) => new NativeFunctionBody(node.nativeToken, _cloneNode(node.stringLiteral), node.semicolon);
 
+  @override
   NullLiteral visitNullLiteral(NullLiteral node) => new NullLiteral(node.literal);
 
+  @override
   ParenthesizedExpression visitParenthesizedExpression(ParenthesizedExpression node) => new ParenthesizedExpression(node.leftParenthesis, _cloneNode(node.expression), node.rightParenthesis);
 
+  @override
   PartDirective visitPartDirective(PartDirective node) => new PartDirective(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.partToken, _cloneNode(node.uri), node.semicolon);
 
+  @override
   PartOfDirective visitPartOfDirective(PartOfDirective node) => new PartOfDirective(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.partToken, node.ofToken, _cloneNode(node.libraryName), node.semicolon);
 
+  @override
   PostfixExpression visitPostfixExpression(PostfixExpression node) => new PostfixExpression(_cloneNode(node.operand), node.operator);
 
+  @override
   PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) => new PrefixedIdentifier(_cloneNode(node.prefix), node.period, _cloneNode(node.identifier));
 
+  @override
   PrefixExpression visitPrefixExpression(PrefixExpression node) => new PrefixExpression(node.operator, _cloneNode(node.operand));
 
+  @override
   PropertyAccess visitPropertyAccess(PropertyAccess node) => new PropertyAccess(_cloneNode(node.target), node.operator, _cloneNode(node.propertyName));
 
+  @override
   RedirectingConstructorInvocation visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) => new RedirectingConstructorInvocation(node.keyword, node.period, _cloneNode(node.constructorName), _cloneNode(node.argumentList));
 
+  @override
   RethrowExpression visitRethrowExpression(RethrowExpression node) => new RethrowExpression(node.keyword);
 
+  @override
   ReturnStatement visitReturnStatement(ReturnStatement node) => new ReturnStatement(node.keyword, _cloneNode(node.expression), node.semicolon);
 
+  @override
   ScriptTag visitScriptTag(ScriptTag node) => new ScriptTag(node.scriptTag);
 
+  @override
   ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator(node.keyword, _cloneNodeList(node.shownNames));
 
+  @override
   SimpleFormalParameter visitSimpleFormalParameter(SimpleFormalParameter node) => new SimpleFormalParameter(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), node.keyword, _cloneNode(node.type), _cloneNode(node.identifier));
 
+  @override
   SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) => new SimpleIdentifier(node.token);
 
+  @override
   SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) => new SimpleStringLiteral(node.literal, node.value);
 
+  @override
   StringInterpolation visitStringInterpolation(StringInterpolation node) => new StringInterpolation(_cloneNodeList(node.elements));
 
+  @override
   SuperConstructorInvocation visitSuperConstructorInvocation(SuperConstructorInvocation node) => new SuperConstructorInvocation(node.keyword, node.period, _cloneNode(node.constructorName), _cloneNode(node.argumentList));
 
+  @override
   SuperExpression visitSuperExpression(SuperExpression node) => new SuperExpression(node.keyword);
 
+  @override
   SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase(_cloneNodeList(node.labels), node.keyword, _cloneNode(node.expression), node.colon, _cloneNodeList(node.statements));
 
+  @override
   SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault(_cloneNodeList(node.labels), node.keyword, node.colon, _cloneNodeList(node.statements));
 
+  @override
   SwitchStatement visitSwitchStatement(SwitchStatement node) => new SwitchStatement(node.keyword, node.leftParenthesis, _cloneNode(node.expression), node.rightParenthesis, node.leftBracket, _cloneNodeList(node.members), node.rightBracket);
 
+  @override
   AstNode visitSymbolLiteral(SymbolLiteral node) => new SymbolLiteral(node.poundSign, node.components);
 
+  @override
   ThisExpression visitThisExpression(ThisExpression node) => new ThisExpression(node.keyword);
 
+  @override
   ThrowExpression visitThrowExpression(ThrowExpression node) => new ThrowExpression(node.keyword, _cloneNode(node.expression));
 
+  @override
   TopLevelVariableDeclaration visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _cloneNode(node.variables), node.semicolon);
 
+  @override
   TryStatement visitTryStatement(TryStatement node) => new TryStatement(node.tryKeyword, _cloneNode(node.body), _cloneNodeList(node.catchClauses), node.finallyKeyword, _cloneNode(node.finallyBlock));
 
+  @override
   TypeArgumentList visitTypeArgumentList(TypeArgumentList node) => new TypeArgumentList(node.leftBracket, _cloneNodeList(node.arguments), node.rightBracket);
 
+  @override
   TypeName visitTypeName(TypeName node) => new TypeName(_cloneNode(node.name), _cloneNode(node.typeArguments));
 
+  @override
   TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _cloneNode(node.name), node.keyword, _cloneNode(node.bound));
 
+  @override
   TypeParameterList visitTypeParameterList(TypeParameterList node) => new TypeParameterList(node.leftBracket, _cloneNodeList(node.typeParameters), node.rightBracket);
 
+  @override
   VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => new VariableDeclaration(null, _cloneNodeList(node.metadata), _cloneNode(node.name), node.equals, _cloneNode(node.initializer));
 
+  @override
   VariableDeclarationList visitVariableDeclarationList(VariableDeclarationList node) => new VariableDeclarationList(null, _cloneNodeList(node.metadata), node.keyword, _cloneNode(node.type), _cloneNodeList(node.variables));
 
+  @override
   VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement(_cloneNode(node.variables), node.semicolon);
 
+  @override
   WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(node.keyword, node.leftParenthesis, _cloneNode(node.condition), node.rightParenthesis, _cloneNode(node.body));
 
+  @override
   WithClause visitWithClause(WithClause node) => new WithClause(node.withKeyword, _cloneNodeList(node.mixinTypes));
 
   AstNode _cloneNode(AstNode node) {
     if (node == null) {
       return null;
     }
     return node.accept(this) as AstNode;
   }
 
   List _cloneNodeList(NodeList nodes) {
@@ skipping 22 matching lines @@
     AstComparator comparator = new AstComparator();
     return comparator._isEqualNodes(first, second);
   }
 
   /**
    * The AST node with which the node being visited is to be compared. This is only valid at the
    * beginning of each visit method (until [isEqualNodes] is invoked).
    */
   AstNode _other;
 
+  @override
   bool visitAdjacentStrings(AdjacentStrings node) {
     AdjacentStrings other = this._other as AdjacentStrings;
     return _isEqualNodeLists(node.strings, other.strings);
   }
 
+  @override
   bool visitAnnotation(Annotation node) {
     Annotation other = this._other as Annotation;
     return _isEqualTokens(node.atSign, other.atSign) && _isEqualNodes(node.name, other.name) && _isEqualTokens(node.period, other.period) && _isEqualNodes(node.constructorName, other.constructorName) && _isEqualNodes(node.arguments, other.arguments);
   }
 
+  @override
   bool visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     ArgumentDefinitionTest other = this._other as ArgumentDefinitionTest;
     return _isEqualTokens(node.question, other.question) && _isEqualNodes(node.identifier, other.identifier);
   }
 
+  @override
   bool visitArgumentList(ArgumentList node) {
     ArgumentList other = this._other as ArgumentList;
     return _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodeLists(node.arguments, other.arguments) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis);
   }
 
+  @override
   bool visitAsExpression(AsExpression node) {
     AsExpression other = this._other as AsExpression;
     return _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.asOperator, other.asOperator) && _isEqualNodes(node.type, other.type);
   }
 
+  @override
   bool visitAssertStatement(AssertStatement node) {
     AssertStatement other = this._other as AssertStatement;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodes(node.condition, other.condition) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression other = this._other as AssignmentExpression;
     return _isEqualNodes(node.leftHandSide, other.leftHandSide) && _isEqualTokens(node.operator, other.operator) && _isEqualNodes(node.rightHandSide, other.rightHandSide);
   }
 
+  @override
   bool visitBinaryExpression(BinaryExpression node) {
     BinaryExpression other = this._other as BinaryExpression;
     return _isEqualNodes(node.leftOperand, other.leftOperand) && _isEqualTokens(node.operator, other.operator) && _isEqualNodes(node.rightOperand, other.rightOperand);
   }
 
+  @override
   bool visitBlock(Block node) {
     Block other = this._other as Block;
     return _isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.statements, other.statements) && _isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
+  @override
   bool visitBlockFunctionBody(BlockFunctionBody node) {
     BlockFunctionBody other = this._other as BlockFunctionBody;
     return _isEqualNodes(node.block, other.block);
   }
 
+  @override
   bool visitBooleanLiteral(BooleanLiteral node) {
     BooleanLiteral other = this._other as BooleanLiteral;
     return _isEqualTokens(node.literal, other.literal) && identical(node.value, other.value);
   }
 
+  @override
   bool visitBreakStatement(BreakStatement node) {
     BreakStatement other = this._other as BreakStatement;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.label, other.label) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitCascadeExpression(CascadeExpression node) {
     CascadeExpression other = this._other as CascadeExpression;
     return _isEqualNodes(node.target, other.target) && _isEqualNodeLists(node.cascadeSections, other.cascadeSections);
   }
 
+  @override
   bool visitCatchClause(CatchClause node) {
     CatchClause other = this._other as CatchClause;
     return _isEqualTokens(node.onKeyword, other.onKeyword) && _isEqualNodes(node.exceptionType, other.exceptionType) && _isEqualTokens(node.catchKeyword, other.catchKeyword) && _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodes(node.exceptionParameter, other.exceptionParameter) && _isEqualTokens(node.comma, other.comma) && _isEqualNodes(node.stackTraceParameter, other.stackTraceParameter) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis) && _isEqualNodes(node.body, other.body);
   }
 
+  @override
   bool visitClassDeclaration(ClassDeclaration node) {
     ClassDeclaration other = this._other as ClassDeclaration;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.abstractKeyword, other.abstractKeyword) && _isEqualTokens(node.classKeyword, other.classKeyword) && _isEqualNodes(node.name, other.name) && _isEqualNodes(node.typeParameters, other.typeParameters) && _isEqualNodes(node.extendsClause, other.extendsClause) && _isEqualNodes(node.withClause, other.withClause) && _isEqualNodes(node.implementsClause, other.implementsClause) && _isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.members, other.members) && _isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
+  @override
   bool visitClassTypeAlias(ClassTypeAlias node) {
     ClassTypeAlias other = this._other as ClassTypeAlias;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.name, other.name) && _isEqualNodes(node.typeParameters, other.typeParameters) && _isEqualTokens(node.equals, other.equals) && _isEqualTokens(node.abstractKeyword, other.abstractKeyword) && _isEqualNodes(node.superclass, other.superclass) && _isEqualNodes(node.withClause, other.withClause) && _isEqualNodes(node.implementsClause, other.implementsClause) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitComment(Comment node) {
     Comment other = this._other as Comment;
     return _isEqualNodeLists(node.references, other.references);
   }
 
+  @override
   bool visitCommentReference(CommentReference node) {
     CommentReference other = this._other as CommentReference;
     return _isEqualTokens(node.newKeyword, other.newKeyword) && _isEqualNodes(node.identifier, other.identifier);
   }
 
+  @override
   bool visitCompilationUnit(CompilationUnit node) {
     CompilationUnit other = this._other as CompilationUnit;
     return _isEqualTokens(node.beginToken, other.beginToken) && _isEqualNodes(node.scriptTag, other.scriptTag) && _isEqualNodeLists(node.directives, other.directives) && _isEqualNodeLists(node.declarations, other.declarations) && _isEqualTokens(node.endToken, other.endToken);
   }
 
+  @override
   bool visitConditionalExpression(ConditionalExpression node) {
     ConditionalExpression other = this._other as ConditionalExpression;
     return _isEqualNodes(node.condition, other.condition) && _isEqualTokens(node.question, other.question) && _isEqualNodes(node.thenExpression, other.thenExpression) && _isEqualTokens(node.colon, other.colon) && _isEqualNodes(node.elseExpression, other.elseExpression);
   }
 
+  @override
   bool visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorDeclaration other = this._other as ConstructorDeclaration;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.externalKeyword, other.externalKeyword) && _isEqualTokens(node.constKeyword, other.constKeyword) && _isEqualTokens(node.factoryKeyword, other.factoryKeyword) && _isEqualNodes(node.returnType, other.returnType) && _isEqualTokens(node.period, other.period) && _isEqualNodes(node.name, other.name) && _isEqualNodes(node.parameters, other.parameters) && _isEqualTokens(node.separator, other.separator) && _isEqualNodeLists(node.initializers, other.initializers) && _isEqualNodes(node.redirectedConstructor, other.redirectedConstructor) && _isEqualNodes(node.body, other.body);
   }
 
+  @override
   bool visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     ConstructorFieldInitializer other = this._other as ConstructorFieldInitializer;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualTokens(node.period, other.period) && _isEqualNodes(node.fieldName, other.fieldName) && _isEqualTokens(node.equals, other.equals) && _isEqualNodes(node.expression, other.expression);
   }
 
+  @override
   bool visitConstructorName(ConstructorName node) {
     ConstructorName other = this._other as ConstructorName;
     return _isEqualNodes(node.type, other.type) && _isEqualTokens(node.period, other.period) && _isEqualNodes(node.name, other.name);
   }
 
+  @override
   bool visitContinueStatement(ContinueStatement node) {
     ContinueStatement other = this._other as ContinueStatement;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.label, other.label) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitDeclaredIdentifier(DeclaredIdentifier node) {
     DeclaredIdentifier other = this._other as DeclaredIdentifier;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.type, other.type) && _isEqualNodes(node.identifier, other.identifier);
   }
 
+  @override
   bool visitDefaultFormalParameter(DefaultFormalParameter node) {
     DefaultFormalParameter other = this._other as DefaultFormalParameter;
     return _isEqualNodes(node.parameter, other.parameter) && identical(node.kind, other.kind) && _isEqualTokens(node.separator, other.separator) && _isEqualNodes(node.defaultValue, other.defaultValue);
   }
 
+  @override
   bool visitDoStatement(DoStatement node) {
     DoStatement other = this._other as DoStatement;
     return _isEqualTokens(node.doKeyword, other.doKeyword) && _isEqualNodes(node.body, other.body) && _isEqualTokens(node.whileKeyword, other.whileKeyword) && _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodes(node.condition, other.condition) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitDoubleLiteral(DoubleLiteral node) {
     DoubleLiteral other = this._other as DoubleLiteral;
     return _isEqualTokens(node.literal, other.literal) && node.value == other.value;
   }
 
+  @override
   bool visitEmptyFunctionBody(EmptyFunctionBody node) {
     EmptyFunctionBody other = this._other as EmptyFunctionBody;
     return _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitEmptyStatement(EmptyStatement node) {
     EmptyStatement other = this._other as EmptyStatement;
     return _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitExportDirective(ExportDirective node) {
     ExportDirective other = this._other as ExportDirective;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.uri, other.uri) && _isEqualNodeLists(node.combinators, other.combinators) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitExpressionFunctionBody(ExpressionFunctionBody node) {
     ExpressionFunctionBody other = this._other as ExpressionFunctionBody;
     return _isEqualTokens(node.functionDefinition, other.functionDefinition) && _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitExpressionStatement(ExpressionStatement node) {
     ExpressionStatement other = this._other as ExpressionStatement;
     return _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitExtendsClause(ExtendsClause node) {
     ExtendsClause other = this._other as ExtendsClause;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.superclass, other.superclass);
   }
 
+  @override
   bool visitFieldDeclaration(FieldDeclaration node) {
     FieldDeclaration other = this._other as FieldDeclaration;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.staticKeyword, other.staticKeyword) && _isEqualNodes(node.fields, other.fields) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitFieldFormalParameter(FieldFormalParameter node) {
     FieldFormalParameter other = this._other as FieldFormalParameter;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.type, other.type) && _isEqualTokens(node.thisToken, other.thisToken) && _isEqualTokens(node.period, other.period) && _isEqualNodes(node.identifier, other.identifier);
   }
 
+  @override
   bool visitForEachStatement(ForEachStatement node) {
     ForEachStatement other = this._other as ForEachStatement;
     return _isEqualTokens(node.forKeyword, other.forKeyword) && _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodes(node.loopVariable, other.loopVariable) && _isEqualTokens(node.inKeyword, other.inKeyword) && _isEqualNodes(node.iterator, other.iterator) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis) && _isEqualNodes(node.body, other.body);
   }
 
+  @override
   bool visitFormalParameterList(FormalParameterList node) {
     FormalParameterList other = this._other as FormalParameterList;
     return _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodeLists(node.parameters, other.parameters) && _isEqualTokens(node.leftDelimiter, other.leftDelimiter) && _isEqualTokens(node.rightDelimiter, other.rightDelimiter) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis);
   }
 
+  @override
   bool visitForStatement(ForStatement node) {
     ForStatement other = this._other as ForStatement;
     return _isEqualTokens(node.forKeyword, other.forKeyword) && _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodes(node.variables, other.variables) && _isEqualNodes(node.initialization, other.initialization) && _isEqualTokens(node.leftSeparator, other.leftSeparator) && _isEqualNodes(node.condition, other.condition) && _isEqualTokens(node.rightSeparator, other.rightSeparator) && _isEqualNodeLists(node.updaters, other.updaters) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis) && _isEqualNodes(node.body, other.body);
   }
 
+  @override
   bool visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionDeclaration other = this._other as FunctionDeclaration;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.externalKeyword, other.externalKeyword) && _isEqualNodes(node.returnType, other.returnType) && _isEqualTokens(node.propertyKeyword, other.propertyKeyword) && _isEqualNodes(node.name, other.name) && _isEqualNodes(node.functionExpression, other.functionExpression);
   }
 
+  @override
   bool visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     FunctionDeclarationStatement other = this._other as FunctionDeclarationStatement;
     return _isEqualNodes(node.functionDeclaration, other.functionDeclaration);
   }
 
+  @override
   bool visitFunctionExpression(FunctionExpression node) {
     FunctionExpression other = this._other as FunctionExpression;
     return _isEqualNodes(node.parameters, other.parameters) && _isEqualNodes(node.body, other.body);
   }
 
+  @override
   bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     FunctionExpressionInvocation other = this._other as FunctionExpressionInvocation;
     return _isEqualNodes(node.function, other.function) && _isEqualNodes(node.argumentList, other.argumentList);
   }
 
+  @override
   bool visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAlias other = this._other as FunctionTypeAlias;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.returnType, other.returnType) && _isEqualNodes(node.name, other.name) && _isEqualNodes(node.typeParameters, other.typeParameters) && _isEqualNodes(node.parameters, other.parameters) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     FunctionTypedFormalParameter other = this._other as FunctionTypedFormalParameter;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualNodes(node.returnType, other.returnType) && _isEqualNodes(node.identifier, other.identifier) && _isEqualNodes(node.parameters, other.parameters);
   }
 
+  @override
   bool visitHideCombinator(HideCombinator node) {
     HideCombinator other = this._other as HideCombinator;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualNodeLists(node.hiddenNames, other.hiddenNames);
   }
 
+  @override
   bool visitIfStatement(IfStatement node) {
     IfStatement other = this._other as IfStatement;
     return _isEqualTokens(node.ifKeyword, other.ifKeyword) && _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodes(node.condition, other.condition) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis) && _isEqualNodes(node.thenStatement, other.thenStatement) && _isEqualTokens(node.elseKeyword, other.elseKeyword) && _isEqualNodes(node.elseStatement, other.elseStatement);
   }
 
+  @override
   bool visitImplementsClause(ImplementsClause node) {
     ImplementsClause other = this._other as ImplementsClause;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualNodeLists(node.interfaces, other.interfaces);
   }
 
+  @override
   bool visitImportDirective(ImportDirective node) {
     ImportDirective other = this._other as ImportDirective;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.uri, other.uri) && _isEqualTokens(node.asToken, other.asToken) && _isEqualNodes(node.prefix, other.prefix) && _isEqualNodeLists(node.combinators, other.combinators) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitIndexExpression(IndexExpression node) {
     IndexExpression other = this._other as IndexExpression;
     return _isEqualNodes(node.target, other.target) && _isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodes(node.index, other.index) && _isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
+  @override
   bool visitInstanceCreationExpression(InstanceCreationExpression node) {
     InstanceCreationExpression other = this._other as InstanceCreationExpression;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.constructorName, other.constructorName) && _isEqualNodes(node.argumentList, other.argumentList);
   }
 
+  @override
   bool visitIntegerLiteral(IntegerLiteral node) {
     IntegerLiteral other = this._other as IntegerLiteral;
     return _isEqualTokens(node.literal, other.literal) && (node.value == other.value);
   }
 
+  @override
   bool visitInterpolationExpression(InterpolationExpression node) {
     InterpolationExpression other = this._other as InterpolationExpression;
     return _isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
+  @override
   bool visitInterpolationString(InterpolationString node) {
     InterpolationString other = this._other as InterpolationString;
     return _isEqualTokens(node.contents, other.contents) && node.value == other.value;
   }
 
+  @override
   bool visitIsExpression(IsExpression node) {
     IsExpression other = this._other as IsExpression;
     return _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.isOperator, other.isOperator) && _isEqualTokens(node.notOperator, other.notOperator) && _isEqualNodes(node.type, other.type);
   }
 
+  @override
   bool visitLabel(Label node) {
     Label other = this._other as Label;
     return _isEqualNodes(node.label, other.label) && _isEqualTokens(node.colon, other.colon);
   }
 
+  @override
   bool visitLabeledStatement(LabeledStatement node) {
     LabeledStatement other = this._other as LabeledStatement;
     return _isEqualNodeLists(node.labels, other.labels) && _isEqualNodes(node.statement, other.statement);
   }
 
+  @override
   bool visitLibraryDirective(LibraryDirective node) {
     LibraryDirective other = this._other as LibraryDirective;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.libraryToken, other.libraryToken) && _isEqualNodes(node.name, other.name) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitLibraryIdentifier(LibraryIdentifier node) {
     LibraryIdentifier other = this._other as LibraryIdentifier;
     return _isEqualNodeLists(node.components, other.components);
   }
 
+  @override
   bool visitListLiteral(ListLiteral node) {
     ListLiteral other = this._other as ListLiteral;
     return _isEqualTokens(node.constKeyword, other.constKeyword) && _isEqualNodes(node.typeArguments, other.typeArguments) && _isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.elements, other.elements) && _isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
+  @override
   bool visitMapLiteral(MapLiteral node) {
     MapLiteral other = this._other as MapLiteral;
     return _isEqualTokens(node.constKeyword, other.constKeyword) && _isEqualNodes(node.typeArguments, other.typeArguments) && _isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.entries, other.entries) && _isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
+  @override
   bool visitMapLiteralEntry(MapLiteralEntry node) {
     MapLiteralEntry other = this._other as MapLiteralEntry;
     return _isEqualNodes(node.key, other.key) && _isEqualTokens(node.separator, other.separator) && _isEqualNodes(node.value, other.value);
   }
 
+  @override
   bool visitMethodDeclaration(MethodDeclaration node) {
     MethodDeclaration other = this._other as MethodDeclaration;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.externalKeyword, other.externalKeyword) && _isEqualTokens(node.modifierKeyword, other.modifierKeyword) && _isEqualNodes(node.returnType, other.returnType) && _isEqualTokens(node.propertyKeyword, other.propertyKeyword) && _isEqualTokens(node.propertyKeyword, other.propertyKeyword) && _isEqualNodes(node.name, other.name) && _isEqualNodes(node.parameters, other.parameters) && _isEqualNodes(node.body, other.body);
   }
 
+  @override
   bool visitMethodInvocation(MethodInvocation node) {
     MethodInvocation other = this._other as MethodInvocation;
     return _isEqualNodes(node.target, other.target) && _isEqualTokens(node.period, other.period) && _isEqualNodes(node.methodName, other.methodName) && _isEqualNodes(node.argumentList, other.argumentList);
   }
 
+  @override
   bool visitNamedExpression(NamedExpression node) {
     NamedExpression other = this._other as NamedExpression;
     return _isEqualNodes(node.name, other.name) && _isEqualNodes(node.expression, other.expression);
   }
 
+  @override
   bool visitNativeClause(NativeClause node) {
     NativeClause other = this._other as NativeClause;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.name, other.name);
   }
 
+  @override
   bool visitNativeFunctionBody(NativeFunctionBody node) {
     NativeFunctionBody other = this._other as NativeFunctionBody;
     return _isEqualTokens(node.nativeToken, other.nativeToken) && _isEqualNodes(node.stringLiteral, other.stringLiteral) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitNullLiteral(NullLiteral node) {
     NullLiteral other = this._other as NullLiteral;
     return _isEqualTokens(node.literal, other.literal);
   }
 
+  @override
   bool visitParenthesizedExpression(ParenthesizedExpression node) {
     ParenthesizedExpression other = this._other as ParenthesizedExpression;
     return _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis);
   }
 
+  @override
   bool visitPartDirective(PartDirective node) {
     PartDirective other = this._other as PartDirective;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.partToken, other.partToken) && _isEqualNodes(node.uri, other.uri) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitPartOfDirective(PartOfDirective node) {
     PartOfDirective other = this._other as PartOfDirective;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.partToken, other.partToken) && _isEqualTokens(node.ofToken, other.ofToken) && _isEqualNodes(node.libraryName, other.libraryName) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitPostfixExpression(PostfixExpression node) {
     PostfixExpression other = this._other as PostfixExpression;
     return _isEqualNodes(node.operand, other.operand) && _isEqualTokens(node.operator, other.operator);
   }
 
+  @override
   bool visitPrefixedIdentifier(PrefixedIdentifier node) {
     PrefixedIdentifier other = this._other as PrefixedIdentifier;
     return _isEqualNodes(node.prefix, other.prefix) && _isEqualTokens(node.period, other.period) && _isEqualNodes(node.identifier, other.identifier);
   }
 
+  @override
   bool visitPrefixExpression(PrefixExpression node) {
     PrefixExpression other = this._other as PrefixExpression;
     return _isEqualTokens(node.operator, other.operator) && _isEqualNodes(node.operand, other.operand);
   }
 
+  @override
   bool visitPropertyAccess(PropertyAccess node) {
     PropertyAccess other = this._other as PropertyAccess;
     return _isEqualNodes(node.target, other.target) && _isEqualTokens(node.operator, other.operator) && _isEqualNodes(node.propertyName, other.propertyName);
   }
 
+  @override
   bool visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     RedirectingConstructorInvocation other = this._other as RedirectingConstructorInvocation;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualTokens(node.period, other.period) && _isEqualNodes(node.constructorName, other.constructorName) && _isEqualNodes(node.argumentList, other.argumentList);
   }
 
+  @override
   bool visitRethrowExpression(RethrowExpression node) {
     RethrowExpression other = this._other as RethrowExpression;
     return _isEqualTokens(node.keyword, other.keyword);
   }
 
+  @override
   bool visitReturnStatement(ReturnStatement node) {
     ReturnStatement other = this._other as ReturnStatement;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitScriptTag(ScriptTag node) {
     ScriptTag other = this._other as ScriptTag;
     return _isEqualTokens(node.scriptTag, other.scriptTag);
   }
 
+  @override
   bool visitShowCombinator(ShowCombinator node) {
     ShowCombinator other = this._other as ShowCombinator;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualNodeLists(node.shownNames, other.shownNames);
   }
 
+  @override
   bool visitSimpleFormalParameter(SimpleFormalParameter node) {
     SimpleFormalParameter other = this._other as SimpleFormalParameter;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.type, other.type) && _isEqualNodes(node.identifier, other.identifier);
   }
 
+  @override
   bool visitSimpleIdentifier(SimpleIdentifier node) {
     SimpleIdentifier other = this._other as SimpleIdentifier;
     return _isEqualTokens(node.token, other.token);
   }
 
+  @override
   bool visitSimpleStringLiteral(SimpleStringLiteral node) {
     SimpleStringLiteral other = this._other as SimpleStringLiteral;
     return _isEqualTokens(node.literal, other.literal) && (node.value == other.value);
   }
 
+  @override
   bool visitStringInterpolation(StringInterpolation node) {
     StringInterpolation other = this._other as StringInterpolation;
     return _isEqualNodeLists(node.elements, other.elements);
   }
 
+  @override
   bool visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     SuperConstructorInvocation other = this._other as SuperConstructorInvocation;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualTokens(node.period, other.period) && _isEqualNodes(node.constructorName, other.constructorName) && _isEqualNodes(node.argumentList, other.argumentList);
   }
 
+  @override
   bool visitSuperExpression(SuperExpression node) {
     SuperExpression other = this._other as SuperExpression;
     return _isEqualTokens(node.keyword, other.keyword);
   }
 
+  @override
   bool visitSwitchCase(SwitchCase node) {
     SwitchCase other = this._other as SwitchCase;
     return _isEqualNodeLists(node.labels, other.labels) && _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.colon, other.colon) && _isEqualNodeLists(node.statements, other.statements);
   }
 
+  @override
   bool visitSwitchDefault(SwitchDefault node) {
     SwitchDefault other = this._other as SwitchDefault;
     return _isEqualNodeLists(node.labels, other.labels) && _isEqualTokens(node.keyword, other.keyword) && _isEqualTokens(node.colon, other.colon) && _isEqualNodeLists(node.statements, other.statements);
   }
 
+  @override
   bool visitSwitchStatement(SwitchStatement node) {
     SwitchStatement other = this._other as SwitchStatement;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodes(node.expression, other.expression) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis) && _isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.members, other.members) && _isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
+  @override
   bool visitSymbolLiteral(SymbolLiteral node) {
     SymbolLiteral other = this._other as SymbolLiteral;
     return _isEqualTokens(node.poundSign, other.poundSign) && _isEqualTokenLists(node.components, other.components);
   }
 
+  @override
   bool visitThisExpression(ThisExpression node) {
     ThisExpression other = this._other as ThisExpression;
     return _isEqualTokens(node.keyword, other.keyword);
   }
 
+  @override
   bool visitThrowExpression(ThrowExpression node) {
     ThrowExpression other = this._other as ThrowExpression;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.expression, other.expression);
   }
 
+  @override
   bool visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     TopLevelVariableDeclaration other = this._other as TopLevelVariableDeclaration;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualNodes(node.variables, other.variables) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitTryStatement(TryStatement node) {
     TryStatement other = this._other as TryStatement;
     return _isEqualTokens(node.tryKeyword, other.tryKeyword) && _isEqualNodes(node.body, other.body) && _isEqualNodeLists(node.catchClauses, other.catchClauses) && _isEqualTokens(node.finallyKeyword, other.finallyKeyword) && _isEqualNodes(node.finallyBlock, other.finallyBlock);
   }
 
+  @override
   bool visitTypeArgumentList(TypeArgumentList node) {
     TypeArgumentList other = this._other as TypeArgumentList;
     return _isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.arguments, other.arguments) && _isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
+  @override
   bool visitTypeName(TypeName node) {
     TypeName other = this._other as TypeName;
     return _isEqualNodes(node.name, other.name) && _isEqualNodes(node.typeArguments, other.typeArguments);
   }
 
+  @override
   bool visitTypeParameter(TypeParameter node) {
     TypeParameter other = this._other as TypeParameter;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualNodes(node.name, other.name) && _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.bound, other.bound);
   }
 
+  @override
   bool visitTypeParameterList(TypeParameterList node) {
     TypeParameterList other = this._other as TypeParameterList;
     return _isEqualTokens(node.leftBracket, other.leftBracket) && _isEqualNodeLists(node.typeParameters, other.typeParameters) && _isEqualTokens(node.rightBracket, other.rightBracket);
   }
 
+  @override
   bool visitVariableDeclaration(VariableDeclaration node) {
     VariableDeclaration other = this._other as VariableDeclaration;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualNodes(node.name, other.name) && _isEqualTokens(node.equals, other.equals) && _isEqualNodes(node.initializer, other.initializer);
   }
 
+  @override
   bool visitVariableDeclarationList(VariableDeclarationList node) {
     VariableDeclarationList other = this._other as VariableDeclarationList;
     return _isEqualNodes(node.documentationComment, other.documentationComment) && _isEqualNodeLists(node.metadata, other.metadata) && _isEqualTokens(node.keyword, other.keyword) && _isEqualNodes(node.type, other.type) && _isEqualNodeLists(node.variables, other.variables);
   }
 
+  @override
   bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     VariableDeclarationStatement other = this._other as VariableDeclarationStatement;
     return _isEqualNodes(node.variables, other.variables) && _isEqualTokens(node.semicolon, other.semicolon);
   }
 
+  @override
   bool visitWhileStatement(WhileStatement node) {
     WhileStatement other = this._other as WhileStatement;
     return _isEqualTokens(node.keyword, other.keyword) && _isEqualTokens(node.leftParenthesis, other.leftParenthesis) && _isEqualNodes(node.condition, other.condition) && _isEqualTokens(node.rightParenthesis, other.rightParenthesis) && _isEqualNodes(node.body, other.body);
   }
 
+  @override
   bool visitWithClause(WithClause node) {
     WithClause other = this._other as WithClause;
     return _isEqualTokens(node.withKeyword, other.withKeyword) && _isEqualNodeLists(node.mixinTypes, other.mixinTypes);
   }
 
   /**
    * Return `true` if the given lists of AST nodes have the same size and corresponding
    * elements are equal.
    *
    * @param first the first node being compared
@@ skipping 106 matching lines @@
    * @param oldNode the node to be replaced
    * @param newNode the replacement node
    * @param tokenMap a mapping of old tokens to new tokens (not `null`)
    */
   IncrementalAstCloner(AstNode oldNode, AstNode newNode, TokenMap tokenMap) {
     this._oldNode = oldNode;
     this._newNode = newNode;
     this._tokenMap = tokenMap;
   }
 
+  @override
   AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => new AdjacentStrings(_cloneNodeList(node.strings));
 
+  @override
   Annotation visitAnnotation(Annotation node) {
     Annotation copy = new Annotation(_mapToken(node.atSign), _cloneNode(node.name), _mapToken(node.period), _cloneNode(node.constructorName), _cloneNode(node.arguments));
     copy.element = node.element;
     return copy;
   }
 
+  @override
   ArgumentDefinitionTest visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     ArgumentDefinitionTest copy = new ArgumentDefinitionTest(_mapToken(node.question), _cloneNode(node.identifier));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList(_mapToken(node.leftParenthesis), _cloneNodeList(node.arguments), _mapToken(node.rightParenthesis));
 
+  @override
   AsExpression visitAsExpression(AsExpression node) {
     AsExpression copy = new AsExpression(_cloneNode(node.expression), _mapToken(node.asOperator), _cloneNode(node.type));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   AstNode visitAssertStatement(AssertStatement node) => new AssertStatement(_mapToken(node.keyword), _mapToken(node.leftParenthesis), _cloneNode(node.condition), _mapToken(node.rightParenthesis), _mapToken(node.semicolon));
 
+  @override
   AssignmentExpression visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression copy = new AssignmentExpression(_cloneNode(node.leftHandSide), _mapToken(node.operator), _cloneNode(node.rightHandSide));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   BinaryExpression visitBinaryExpression(BinaryExpression node) {
     BinaryExpression copy = new BinaryExpression(_cloneNode(node.leftOperand), _mapToken(node.operator), _cloneNode(node.rightOperand));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   Block visitBlock(Block node) => new Block(_mapToken(node.leftBracket), _cloneNodeList(node.statements), _mapToken(node.rightBracket));
 
+  @override
   BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => new BlockFunctionBody(_cloneNode(node.block));
 
+  @override
   BooleanLiteral visitBooleanLiteral(BooleanLiteral node) {
     BooleanLiteral copy = new BooleanLiteral(_mapToken(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement(_mapToken(node.keyword), _cloneNode(node.label), _mapToken(node.semicolon));
 
+  @override
   CascadeExpression visitCascadeExpression(CascadeExpression node) {
     CascadeExpression copy = new CascadeExpression(_cloneNode(node.target), _cloneNodeList(node.cascadeSections));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   CatchClause visitCatchClause(CatchClause node) => new CatchClause(_mapToken(node.onKeyword), _cloneNode(node.exceptionType), _mapToken(node.catchKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.exceptionParameter), _mapToken(node.comma), _cloneNode(node.stackTraceParameter), _mapToken(node.rightParenthesis), _cloneNode(node.body));
 
+  @override
   ClassDeclaration visitClassDeclaration(ClassDeclaration node) {
     ClassDeclaration copy = new ClassDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.abstractKeyword), _mapToken(node.classKeyword), _cloneNode(node.name), _cloneNode(node.typeParameters), _cloneNode(node.extendsClause), _cloneNode(node.withClause), _cloneNode(node.implementsClause), _mapToken(node.leftBracket), _cloneNodeList(node.members), _mapToken(node.rightBracket));
     copy.nativeClause = _cloneNode(node.nativeClause);
     return copy;
   }
 
+  @override
   ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => new ClassTypeAlias(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), _cloneNode(node.name), _cloneNode(node.typeParameters), _mapToken(node.equals), _mapToken(node.abstractKeyword), _cloneNode(node.superclass), _cloneNode(node.withClause), _cloneNode(node.implementsClause), _mapToken(node.semicolon));
 
+  @override
   Comment visitComment(Comment node) {
     if (node.isDocumentation) {
       return Comment.createDocumentationCommentWithReferences(_mapTokens(node.tokens), _cloneNodeList(node.references));
     } else if (node.isBlock) {
       return Comment.createBlockComment(_mapTokens(node.tokens));
     }
     return Comment.createEndOfLineComment(_mapTokens(node.tokens));
   }
 
+  @override
   CommentReference visitCommentReference(CommentReference node) => new CommentReference(_mapToken(node.newKeyword), _cloneNode(node.identifier));
 
+  @override
   CompilationUnit visitCompilationUnit(CompilationUnit node) {
     CompilationUnit copy = new CompilationUnit(_mapToken(node.beginToken), _cloneNode(node.scriptTag), _cloneNodeList(node.directives), _cloneNodeList(node.declarations), _mapToken(node.endToken));
     copy.lineInfo = node.lineInfo;
     copy.element = node.element;
     return copy;
   }
 
+  @override
   ConditionalExpression visitConditionalExpression(ConditionalExpression node) {
     ConditionalExpression copy = new ConditionalExpression(_cloneNode(node.condition), _mapToken(node.question), _cloneNode(node.thenExpression), _mapToken(node.colon), _cloneNode(node.elseExpression));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   ConstructorDeclaration visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorDeclaration copy = new ConstructorDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.externalKeyword), _mapToken(node.constKeyword), _mapToken(node.factoryKeyword), _cloneNode(node.returnType), _mapToken(node.period), _cloneNode(node.name), _cloneNode(node.parameters), _mapToken(node.separator), _cloneNodeList(node.initializers), _cloneNode(node.redirectedConstructor), _cloneNode(node.body));
     copy.element = node.element;
     return copy;
   }
 
+  @override
   ConstructorFieldInitializer visitConstructorFieldInitializer(ConstructorFieldInitializer node) => new ConstructorFieldInitializer(_mapToken(node.keyword), _mapToken(node.period), _cloneNode(node.fieldName), _mapToken(node.equals), _cloneNode(node.expression));
 
+  @override
   ConstructorName visitConstructorName(ConstructorName node) {
     ConstructorName copy = new ConstructorName(_cloneNode(node.type), _mapToken(node.period), _cloneNode(node.name));
     copy.staticElement = node.staticElement;
     return copy;
   }
 
+  @override
   ContinueStatement visitContinueStatement(ContinueStatement node) => new ContinueStatement(_mapToken(node.keyword), _cloneNode(node.label), _mapToken(node.semicolon));
 
+  @override
   DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) => new DeclaredIdentifier(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), _cloneNode(node.type), _cloneNode(node.identifier));
 
+  @override
   DefaultFormalParameter visitDefaultFormalParameter(DefaultFormalParameter node) => new DefaultFormalParameter(_cloneNode(node.parameter), node.kind, _mapToken(node.separator), _cloneNode(node.defaultValue));
 
+  @override
   DoStatement visitDoStatement(DoStatement node) => new DoStatement(_mapToken(node.doKeyword), _cloneNode(node.body), _mapToken(node.whileKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.condition), _mapToken(node.rightParenthesis), _mapToken(node.semicolon));
 
+  @override
   DoubleLiteral visitDoubleLiteral(DoubleLiteral node) {
     DoubleLiteral copy = new DoubleLiteral(_mapToken(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) => new EmptyFunctionBody(_mapToken(node.semicolon));
 
+  @override
   EmptyStatement visitEmptyStatement(EmptyStatement node) => new EmptyStatement(_mapToken(node.semicolon));
 
+  @override
   ExportDirective visitExportDirective(ExportDirective node) {
     ExportDirective copy = new ExportDirective(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), _cloneNode(node.uri), _cloneNodeList(node.combinators), _mapToken(node.semicolon));
     copy.element = node.element;
     return copy;
   }
 
+  @override
   ExpressionFunctionBody visitExpressionFunctionBody(ExpressionFunctionBody node) => new ExpressionFunctionBody(_mapToken(node.functionDefinition), _cloneNode(node.expression), _mapToken(node.semicolon));
 
+  @override
   ExpressionStatement visitExpressionStatement(ExpressionStatement node) => new ExpressionStatement(_cloneNode(node.expression), _mapToken(node.semicolon));
 
+  @override
   ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause(_mapToken(node.keyword), _cloneNode(node.superclass));
 
+  @override
   FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => new FieldDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.staticKeyword), _cloneNode(node.fields), _mapToken(node.semicolon));
 
+  @override
   FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => new FieldFormalParameter(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), _cloneNode(node.type), _mapToken(node.thisToken), _mapToken(node.period), _cloneNode(node.identifier), _cloneNode(node.parameters));
 
+  @override
   ForEachStatement visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable == null) {
       return new ForEachStatement.con2(_mapToken(node.forKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.identifier), _mapToken(node.inKeyword), _cloneNode(node.iterator), _mapToken(node.rightParenthesis), _cloneNode(node.body));
     }
     return new ForEachStatement.con1(_mapToken(node.forKeyword), _mapToken(node.leftParenthesis), _cloneNode(loopVariable), _mapToken(node.inKeyword), _cloneNode(node.iterator), _mapToken(node.rightParenthesis), _cloneNode(node.body));
   }
 
+  @override
   FormalParameterList visitFormalParameterList(FormalParameterList node) => new FormalParameterList(_mapToken(node.leftParenthesis), _cloneNodeList(node.parameters), _mapToken(node.leftDelimiter), _mapToken(node.rightDelimiter), _mapToken(node.rightParenthesis));
 
+  @override
   ForStatement visitForStatement(ForStatement node) => new ForStatement(_mapToken(node.forKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.variables), _cloneNode(node.initialization), _mapToken(node.leftSeparator), _cloneNode(node.condition), _mapToken(node.rightSeparator), _cloneNodeList(node.updaters), _mapToken(node.rightParenthesis), _cloneNode(node.body));
 
+  @override
   FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => new FunctionDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.externalKeyword), _cloneNode(node.returnType), _mapToken(node.propertyKeyword), _cloneNode(node.name), _cloneNode(node.functionExpression));
 
+  @override
   FunctionDeclarationStatement visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => new FunctionDeclarationStatement(_cloneNode(node.functionDeclaration));
 
+  @override
   FunctionExpression visitFunctionExpression(FunctionExpression node) {
     FunctionExpression copy = new FunctionExpression(_cloneNode(node.parameters), _cloneNode(node.body));
     copy.element = node.element;
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   FunctionExpressionInvocation visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     FunctionExpressionInvocation copy = new FunctionExpressionInvocation(_cloneNode(node.function), _cloneNode(node.argumentList));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => new FunctionTypeAlias(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), _cloneNode(node.returnType), _cloneNode(node.name), _cloneNode(node.typeParameters), _cloneNode(node.parameters), _mapToken(node.semicolon));
 
+  @override
   FunctionTypedFormalParameter visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) => new FunctionTypedFormalParameter(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _cloneNode(node.returnType), _cloneNode(node.identifier), _cloneNode(node.parameters));
 
+  @override
   HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator(_mapToken(node.keyword), _cloneNodeList(node.hiddenNames));
 
+  @override
   IfStatement visitIfStatement(IfStatement node) => new IfStatement(_mapToken(node.ifKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.condition), _mapToken(node.rightParenthesis), _cloneNode(node.thenStatement), _mapToken(node.elseKeyword), _cloneNode(node.elseStatement));
 
+  @override
   ImplementsClause visitImplementsClause(ImplementsClause node) => new ImplementsClause(_mapToken(node.keyword), _cloneNodeList(node.interfaces));
 
+  @override
   ImportDirective visitImportDirective(ImportDirective node) => new ImportDirective(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), _cloneNode(node.uri), _mapToken(node.asToken), _cloneNode(node.prefix), _cloneNodeList(node.combinators), _mapToken(node.semicolon));
 
+  @override
   IndexExpression visitIndexExpression(IndexExpression node) {
     Token period = _mapToken(node.period);
     IndexExpression copy;
     if (period == null) {
       copy = new IndexExpression.forTarget(_cloneNode(node.target), _mapToken(node.leftBracket), _cloneNode(node.index), _mapToken(node.rightBracket));
     } else {
       copy = new IndexExpression.forCascade(period, _mapToken(node.leftBracket), _cloneNode(node.index), _mapToken(node.rightBracket));
     }
     copy.auxiliaryElements = node.auxiliaryElements;
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   InstanceCreationExpression visitInstanceCreationExpression(InstanceCreationExpression node) {
     InstanceCreationExpression copy = new InstanceCreationExpression(_mapToken(node.keyword), _cloneNode(node.constructorName), _cloneNode(node.argumentList));
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   IntegerLiteral visitIntegerLiteral(IntegerLiteral node) {
     IntegerLiteral copy = new IntegerLiteral(_mapToken(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   InterpolationExpression visitInterpolationExpression(InterpolationExpression node) => new InterpolationExpression(_mapToken(node.leftBracket), _cloneNode(node.expression), _mapToken(node.rightBracket));
 
+  @override
   InterpolationString visitInterpolationString(InterpolationString node) => new InterpolationString(_mapToken(node.contents), node.value);
 
+  @override
   IsExpression visitIsExpression(IsExpression node) {
     IsExpression copy = new IsExpression(_cloneNode(node.expression), _mapToken(node.isOperator), _mapToken(node.notOperator), _cloneNode(node.type));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   Label visitLabel(Label node) => new Label(_cloneNode(node.label), _mapToken(node.colon));
 
+  @override
   LabeledStatement visitLabeledStatement(LabeledStatement node) => new LabeledStatement(_cloneNodeList(node.labels), _cloneNode(node.statement));
 
+  @override
   LibraryDirective visitLibraryDirective(LibraryDirective node) => new LibraryDirective(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.libraryToken), _cloneNode(node.name), _mapToken(node.semicolon));
 
+  @override
   LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) {
     LibraryIdentifier copy = new LibraryIdentifier(_cloneNodeList(node.components));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   ListLiteral visitListLiteral(ListLiteral node) {
     ListLiteral copy = new ListLiteral(_mapToken(node.constKeyword), _cloneNode(node.typeArguments), _mapToken(node.leftBracket), _cloneNodeList(node.elements), _mapToken(node.rightBracket));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   MapLiteral visitMapLiteral(MapLiteral node) {
     MapLiteral copy = new MapLiteral(_mapToken(node.constKeyword), _cloneNode(node.typeArguments), _mapToken(node.leftBracket), _cloneNodeList(node.entries), _mapToken(node.rightBracket));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) => new MapLiteralEntry(_cloneNode(node.key), _mapToken(node.separator), _cloneNode(node.value));
 
+  @override
   MethodDeclaration visitMethodDeclaration(MethodDeclaration node) => new MethodDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.externalKeyword), _mapToken(node.modifierKeyword), _cloneNode(node.returnType), _mapToken(node.propertyKeyword), _mapToken(node.operatorKeyword), _cloneNode(node.name), _cloneNode(node.parameters), _cloneNode(node.body));
 
+  @override
   MethodInvocation visitMethodInvocation(MethodInvocation node) {
     MethodInvocation copy = new MethodInvocation(_cloneNode(node.target), _mapToken(node.period), _cloneNode(node.methodName), _cloneNode(node.argumentList));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   NamedExpression visitNamedExpression(NamedExpression node) {
     NamedExpression copy = new NamedExpression(_cloneNode(node.name), _cloneNode(node.expression));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   AstNode visitNativeClause(NativeClause node) => new NativeClause(_mapToken(node.keyword), _cloneNode(node.name));
 
+  @override
   NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) => new NativeFunctionBody(_mapToken(node.nativeToken), _cloneNode(node.stringLiteral), _mapToken(node.semicolon));
 
+  @override
   NullLiteral visitNullLiteral(NullLiteral node) {
     NullLiteral copy = new NullLiteral(_mapToken(node.literal));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   ParenthesizedExpression visitParenthesizedExpression(ParenthesizedExpression node) {
     ParenthesizedExpression copy = new ParenthesizedExpression(_mapToken(node.leftParenthesis), _cloneNode(node.expression), _mapToken(node.rightParenthesis));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   PartDirective visitPartDirective(PartDirective node) {
     PartDirective copy = new PartDirective(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.partToken), _cloneNode(node.uri), _mapToken(node.semicolon));
     copy.element = node.element;
     return copy;
   }
 
+  @override
   PartOfDirective visitPartOfDirective(PartOfDirective node) {
     PartOfDirective copy = new PartOfDirective(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.partToken), _mapToken(node.ofToken), _cloneNode(node.libraryName), _mapToken(node.semicolon));
     copy.element = node.element;
     return copy;
   }
 
+  @override
   PostfixExpression visitPostfixExpression(PostfixExpression node) {
     PostfixExpression copy = new PostfixExpression(_cloneNode(node.operand), _mapToken(node.operator));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) {
     PrefixedIdentifier copy = new PrefixedIdentifier(_cloneNode(node.prefix), _mapToken(node.period), _cloneNode(node.identifier));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   PrefixExpression visitPrefixExpression(PrefixExpression node) {
     PrefixExpression copy = new PrefixExpression(_mapToken(node.operator), _cloneNode(node.operand));
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   PropertyAccess visitPropertyAccess(PropertyAccess node) {
     PropertyAccess copy = new PropertyAccess(_cloneNode(node.target), _mapToken(node.operator), _cloneNode(node.propertyName));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   RedirectingConstructorInvocation visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     RedirectingConstructorInvocation copy = new RedirectingConstructorInvocation(_mapToken(node.keyword), _mapToken(node.period), _cloneNode(node.constructorName), _cloneNode(node.argumentList));
     copy.staticElement = node.staticElement;
     return copy;
   }
 
+  @override
   RethrowExpression visitRethrowExpression(RethrowExpression node) {
     RethrowExpression copy = new RethrowExpression(_mapToken(node.keyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   ReturnStatement visitReturnStatement(ReturnStatement node) => new ReturnStatement(_mapToken(node.keyword), _cloneNode(node.expression), _mapToken(node.semicolon));
 
+  @override
   ScriptTag visitScriptTag(ScriptTag node) => new ScriptTag(_mapToken(node.scriptTag));
 
+  @override
   ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator(_mapToken(node.keyword), _cloneNodeList(node.shownNames));
 
+  @override
   SimpleFormalParameter visitSimpleFormalParameter(SimpleFormalParameter node) => new SimpleFormalParameter(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), _cloneNode(node.type), _cloneNode(node.identifier));
 
+  @override
   SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) {
     Token mappedToken = _mapToken(node.token);
     if (mappedToken == null) {
       // This only happens for SimpleIdentifiers created by the parser as part of scanning
       // documentation comments (the tokens for those identifiers are not in the original token
       // stream and hence do not get copied). This extra check can be removed if the scanner is
       // changed to scan documentation comments for the parser.
       mappedToken = node.token;
     }
     SimpleIdentifier copy = new SimpleIdentifier(mappedToken);
     copy.auxiliaryElements = node.auxiliaryElements;
     copy.propagatedElement = node.propagatedElement;
     copy.propagatedType = node.propagatedType;
     copy.staticElement = node.staticElement;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) {
     SimpleStringLiteral copy = new SimpleStringLiteral(_mapToken(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   StringInterpolation visitStringInterpolation(StringInterpolation node) {
     StringInterpolation copy = new StringInterpolation(_cloneNodeList(node.elements));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   SuperConstructorInvocation visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     SuperConstructorInvocation copy = new SuperConstructorInvocation(_mapToken(node.keyword), _mapToken(node.period), _cloneNode(node.constructorName), _cloneNode(node.argumentList));
     copy.staticElement = node.staticElement;
     return copy;
   }
 
+  @override
   SuperExpression visitSuperExpression(SuperExpression node) {
     SuperExpression copy = new SuperExpression(_mapToken(node.keyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase(_cloneNodeList(node.labels), _mapToken(node.keyword), _cloneNode(node.expression), _mapToken(node.colon), _cloneNodeList(node.statements));
 
+  @override
   SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault(_cloneNodeList(node.labels), _mapToken(node.keyword), _mapToken(node.colon), _cloneNodeList(node.statements));
 
+  @override
   SwitchStatement visitSwitchStatement(SwitchStatement node) => new SwitchStatement(_mapToken(node.keyword), _mapToken(node.leftParenthesis), _cloneNode(node.expression), _mapToken(node.rightParenthesis), _mapToken(node.leftBracket), _cloneNodeList(node.members), _mapToken(node.rightBracket));
 
+  @override
   AstNode visitSymbolLiteral(SymbolLiteral node) {
     SymbolLiteral copy = new SymbolLiteral(_mapToken(node.poundSign), _mapTokens(node.components));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   ThisExpression visitThisExpression(ThisExpression node) {
     ThisExpression copy = new ThisExpression(_mapToken(node.keyword));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   ThrowExpression visitThrowExpression(ThrowExpression node) {
     ThrowExpression copy = new ThrowExpression(_mapToken(node.keyword), _cloneNode(node.expression));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
+  @override
   TopLevelVariableDeclaration visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) => new TopLevelVariableDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _cloneNode(node.variables), _mapToken(node.semicolon));
 
+  @override
   TryStatement visitTryStatement(TryStatement node) => new TryStatement(_mapToken(node.tryKeyword), _cloneNode(node.body), _cloneNodeList(node.catchClauses), _mapToken(node.finallyKeyword), _cloneNode(node.finallyBlock));
 
+  @override
   TypeArgumentList visitTypeArgumentList(TypeArgumentList node) => new TypeArgumentList(_mapToken(node.leftBracket), _cloneNodeList(node.arguments), _mapToken(node.rightBracket));
 
+  @override
   TypeName visitTypeName(TypeName node) {
     TypeName copy = new TypeName(_cloneNode(node.name), _cloneNode(node.typeArguments));
     copy.type = node.type;
     return copy;
   }
 
+  @override
   TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _cloneNode(node.name), _mapToken(node.keyword), _cloneNode(node.bound));
 
+  @override
   TypeParameterList visitTypeParameterList(TypeParameterList node) => new TypeParameterList(_mapToken(node.leftBracket), _cloneNodeList(node.typeParameters), _mapToken(node.rightBracket));
 
+  @override
   VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => new VariableDeclaration(null, _cloneNodeList(node.metadata), _cloneNode(node.name), _mapToken(node.equals), _cloneNode(node.initializer));
 
+  @override
   VariableDeclarationList visitVariableDeclarationList(VariableDeclarationList node) => new VariableDeclarationList(null, _cloneNodeList(node.metadata), _mapToken(node.keyword), _cloneNode(node.type), _cloneNodeList(node.variables));
 
+  @override
   VariableDeclarationStatement visitVariableDeclarationStatement(VariableDeclarationStatement node) => new VariableDeclarationStatement(_cloneNode(node.variables), _mapToken(node.semicolon));
 
+  @override
   WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement(_mapToken(node.keyword), _mapToken(node.leftParenthesis), _cloneNode(node.condition), _mapToken(node.rightParenthesis), _cloneNode(node.body));
 
+  @override
   WithClause visitWithClause(WithClause node) => new WithClause(_mapToken(node.withKeyword), _cloneNodeList(node.mixinTypes));
 
   AstNode _cloneNode(AstNode node) {
     if (node == null) {
       return null;
     }
     if (identical(node, _oldNode)) {
       return _newNode;
     }
     return node.accept(this) as AstNode;
@@ skipping 43 matching lines @@
   bool _referenceIsWithinLocalFunction = false;
 
   ScopedNameFinder(int position) {
     this._position = position;
   }
 
   Declaration get declaration => _declarationNode;
 
   Map<String, SimpleIdentifier> get locals => _locals;
 
+  @override
   Object visitBlock(Block node) {
     _checkStatements(node.statements);
     return super.visitBlock(node);
   }
 
+  @override
   Object visitCatchClause(CatchClause node) {
     _addToScope(node.exceptionParameter);
     _addToScope(node.stackTraceParameter);
     return super.visitCatchClause(node);
   }
 
+  @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     if (_immediateChild != node.parameters) {
       _addParameters(node.parameters.parameters);
     }
     _declarationNode = node;
     return null;
   }
 
+  @override
   Object visitFieldDeclaration(FieldDeclaration node) {
     _declarationNode = node;
     return null;
   }
 
+  @override
   Object visitForEachStatement(ForEachStatement node) {
     DeclaredIdentifier loopVariable = node.loopVariable;
     if (loopVariable != null) {
       _addToScope(loopVariable.identifier);
     }
     return super.visitForEachStatement(node);
   }
 
+  @override
   Object visitForStatement(ForStatement node) {
     if (_immediateChild != node.variables && node.variables != null) {
       _addVariables(node.variables.variables);
     }
     return super.visitForStatement(node);
   }
 
+  @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     if (node.parent is! FunctionDeclarationStatement) {
       _declarationNode = node;
       return null;
     }
     return super.visitFunctionDeclaration(node);
   }
 
+  @override
   Object visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     _referenceIsWithinLocalFunction = true;
     return super.visitFunctionDeclarationStatement(node);
   }
 
+  @override
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parameters != null && _immediateChild != node.parameters) {
       _addParameters(node.parameters.parameters);
     }
     return super.visitFunctionExpression(node);
   }
 
+  @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     _declarationNode = node;
     if (node.parameters == null) {
       return null;
     }
     if (_immediateChild != node.parameters) {
       _addParameters(node.parameters.parameters);
     }
     return null;
   }
 
+  @override
   Object visitNode(AstNode node) {
     _immediateChild = node;
     AstNode parent = node.parent;
     if (parent != null) {
       parent.accept(this);
     }
     return null;
   }
 
+  @override
   Object visitSwitchMember(SwitchMember node) {
     _checkStatements(node.statements);
     return super.visitSwitchMember(node);
   }
 
+  @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _declarationNode = node;
     return null;
   }
 
+  @override
   Object visitTypeAlias(TypeAlias node) {
     _declarationNode = node;
     return null;
   }
 
   void _addParameters(NodeList<FormalParameter> vars) {
     for (FormalParameter var2 in vars) {
       _addToScope(var2.identifier);
     }
   }
@@ skipping 154 matching lines @@
       throw new RangeError("Index: ${index}, Size: ${_elements.length}");
     }
     owner.becomeParentOf(node);
     _elements[index] = node;
   }
   int get length => _elements.length;
   void set length(int value) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 }