java2dart improvements and new analyzer_experimental snapshot.

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

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.ast;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'error.dart';
 import 'source.dart' show LineInfo;
 import 'scanner.dart';
 import 'engine.dart' show AnalysisEngine;
@@ skipping 191 matching lines @@
     return writer.toString();
   }
   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<Object> visitor);
+  void visitChildren(ASTVisitor visitor);
 
   /**
    * Make this node the parent of the given child node.
    *
    * @param child the node that will become a child of this node
    * @return the node that was made a child of this node
    */
   ASTNode becomeParentOf(ASTNode child) {
     if (child != null) {
       ASTNode node = child;
       node.parent = this;
     }
     return child;
   }
 
   /**
    * If the given child is not `null`, use the given visitor to visit it.
    *
    * @param child the child to be visited
    * @param visitor the visitor that will be used to visit the child
    */
-  void safelyVisitChild(ASTNode child, ASTVisitor<Object> visitor) {
+  void safelyVisitChild(ASTNode child, ASTVisitor visitor) {
     if (child != null) {
       child.accept(visitor);
     }
   }
 
   /**
    * Set the parent of this node to the given node.
    *
    * @param newParent the node that is to be made the parent of this node
    */
@@ skipping 154 matching lines @@
   accept(ASTVisitor visitor) => visitor.visitAdjacentStrings(this);
   Token get beginToken => _strings.beginToken;
   Token get endToken => _strings.endToken;
 
   /**
    * Return the strings that are implicitly concatenated.
    *
    * @return the strings that are implicitly concatenated
    */
   NodeList<StringLiteral> get strings => _strings;
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     _strings.accept(visitor);
   }
   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
@@ skipping 77 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> metadata2) {
     this._metadata.clear();
     this._metadata.addAll(metadata2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
   }
 
@@ skipping 232 matching lines @@
   }
 
   /**
    * Set the period before the constructor name to the given token.
    *
    * @param period the period before the constructor name
    */
   void set period(Token period2) {
     this._period = period2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_arguments, visitor);
   }
 }
 /**
  * Instances of the class `ArgumentDefinitionTest` represent an argument definition test.
  *
  * <pre>
  * argumentDefinitionTest ::=
@@ skipping 60 matching lines @@
   }
 
   /**
    * Set the token representing the question mark to the given token.
    *
    * @param question the token representing the question mark
    */
   void set question(Token question2) {
     this._question = question2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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>
  * argumentList ::=
  *     '(' arguments? ')'
@@ skipping 129 matching lines @@
   }
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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 130 matching lines @@
   }
 
   /**
    * 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 /**
  * Instances of the class `AssertStatement` represent an assert statement.
  *
  * <pre>
  * assertStatement ::=
  *     'assert' '(' [Expression] ')' ';'
@@ skipping 131 matching lines @@
   }
 
   /**
    * Set the semicolon terminating the statement to the given token.
    *
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_condition, visitor);
   }
 }
 /**
  * Instances of the class `AssignmentExpression` represent an assignment expression.
  *
  * <pre>
  * assignmentExpression ::=
  *     [Expression] [Token] [Expression]
  * </pre>
@@ skipping 152 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;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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`.
    *
    * This method is only intended to be used by [Expression#getPropagatedParameterElement].
@@ skipping 195 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;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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`.
    *
    * This method is only intended to be used by [Expression#getPropagatedParameterElement].
@@ skipping 117 matching lines @@
   }
 
   /**
    * Set the right curly bracket to the given token.
    *
    * @param rightBracket the right curly bracket
    */
   void set rightBracket(Token rightBracket2) {
     this._rightBracket = rightBracket2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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]
@@ skipping 35 matching lines @@
   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 block2) {
     this._block = becomeParentOf(block2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_block, visitor);
   }
 }
 /**
  * Instances of the class `BooleanLiteral` represent a boolean literal expression.
  *
  * <pre>
  * booleanLiteral ::=
  *     'false' | 'true'
  * </pre>
@@ skipping 59 matching lines @@
   }
 
   /**
    * Set the value of the literal to the given value.
    *
    * @param value the value of the literal
    */
   void set value(bool value2) {
     this._value = value2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 }
 /**
  * Instances of the class `BreakStatement` represent a break statement.
  *
  * <pre>
  * breakStatement ::=
  *     'break' [SimpleIdentifier]? ';'
  * </pre>
  *
@@ skipping 81 matching lines @@
   }
 
   /**
    * Set the semicolon terminating the statement to the given token.
    *
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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].
  *
  * <pre>
@@ skipping 60 matching lines @@
   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 target2) {
     this._target = becomeParentOf(target2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_target, visitor);
     _cascadeSections.accept(visitor);
   }
 }
 /**
  * Instances of the class `CatchClause` represent a catch clause within a try statement.
  *
  * <pre>
  * onPart ::=
  *     catchPart [Block]
@@ skipping 244 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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.
  *
  * <pre>
@@ skipping 279 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 withClause2) {
     this._withClause = becomeParentOf(withClause2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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);
   }
   Token get firstTokenAfterCommentAndMetadata {
@@ skipping 229 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 withClause2) {
     this._withClause = becomeParentOf(withClause2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_superclass, visitor);
     safelyVisitChild(_withClause, visitor);
     safelyVisitChild(_implementsClause, visitor);
   }
 }
 /**
  * Instances of the class `Combinator` represent the combinator associated with an import
@@ skipping 177 matching lines @@
    * @return `true` if this is a documentation comment
    */
   bool get isDocumentation => identical(_type, CommentType.DOCUMENTATION);
 
   /**
    * Return `true` if this is an end-of-line comment.
    *
    * @return `true` if this is an end-of-line comment
    */
   bool get isEndOfLine => identical(_type, CommentType.END_OF_LINE);
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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 implements Enum<CommentType> {
+class CommentType extends Enum<CommentType> {
 
   /**
    * An end-of-line comment.
    */
   static final CommentType END_OF_LINE = new CommentType('END_OF_LINE', 0);
 
   /**
    * A block comment.
    */
   static final CommentType BLOCK = new CommentType('BLOCK', 1);
 
   /**
    * A documentation comment.
    */
   static final CommentType DOCUMENTATION = new CommentType('DOCUMENTATION', 2);
   static final List<CommentType> values = [END_OF_LINE, BLOCK, DOCUMENTATION];
-
-  /// The name of this enum constant, as declared in the enum declaration.
-  final String name;
-
-  /// The position in the enum declaration.
-  final int ordinal;
-  CommentType(this.name, this.ordinal);
-  int compareTo(CommentType other) => ordinal - other.ordinal;
-  int get hashCode => ordinal;
-  String toString() => name;
+  CommentType(String name, int ordinal) : super(name, ordinal);
 }
 /**
  * Instances of the class `CommentReference` represent a reference to a Dart element that is
  * found within a documentation comment.
  *
  * <pre>
  * commentReference ::=
  *     '[' 'new'? [Identifier] ']'
  * </pre>
  *
@@ skipping 57 matching lines @@
   }
 
   /**
    * Set the token representing the 'new' keyword to the given token.
    *
    * @param newKeyword the token representing the 'new' keyword
    */
   void set newKeyword(Token newKeyword2) {
     this._newKeyword = newKeyword2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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
  * compilation unit will be visited in lexical order even if lexical order does not conform to the
  * restrictions of the grammar.
@@ skipping 217 matching lines @@
   }
 
   /**
    * Set the script tag at the beginning of the compilation unit to the given script tag.
    *
    * @param scriptTag the script tag at the beginning of the compilation unit
    */
   void set scriptTag(ScriptTag scriptTag2) {
     this._scriptTag = becomeParentOf(scriptTag2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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 209 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_thenExpression, visitor);
     safelyVisitChild(_elseExpression, visitor);
   }
 }
 /**
  * Instances of the class `ConstructorDeclaration` represent a constructor declaration.
  *
  * <pre>
  * constructorDeclaration ::=
@@ skipping 326 matching lines @@
   }
 
   /**
    * Set the token for the separator (colon or equals) before the initializers to the given token.
    *
    * @param separator the token for the separator (colon or equals) before the initializers
    */
   void set separator(Token separator2) {
     this._separator = separator2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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);
   }
   Token get firstTokenAfterCommentAndMetadata {
     Token leftMost2 = leftMost([_externalKeyword, _constKeyword, _factoryKeyword]);
@@ skipping 172 matching lines @@
   }
 
   /**
    * Set the token for the period after the 'this' keyword to the given token.
    *
    * @param period the token for the period after the 'this' keyword
    */
   void set period(Token period2) {
     this._period = period2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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.
  *
  * <pre>
  * constructorInitializer ::=
@@ skipping 158 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 type2) {
     this._type = becomeParentOf(type2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_type, visitor);
     safelyVisitChild(_name, visitor);
   }
 }
 /**
  * Instances of the class `ContinueStatement` represent a continue statement.
  *
  * <pre>
  * continueStatement ::=
  *     'continue' [SimpleIdentifier]? ';'
@@ skipping 83 matching lines @@
   }
 
   /**
    * Set the semicolon terminating the statement to the given token.
    *
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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.
  *
  * @coverage dart.engine.ast
  */
 abstract class Declaration extends AnnotatedNode {
@@ skipping 136 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(_identifier, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_keyword != null) {
       return _keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
@@ skipping 127 matching lines @@
   }
 
   /**
    * Set the token separating the parameter from the default value to the given token.
    *
    * @param separator the token separating the parameter from the default value
    */
   void set separator(Token separator2) {
     this._separator = separator2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_parameter, visitor);
     safelyVisitChild(_defaultValue, visitor);
   }
 }
 /**
  * The abstract class `Directive` defines the behavior common to nodes that represent a
  * directive.
  *
  * <pre>
  * directive ::=
@@ skipping 244 matching lines @@
   }
 
   /**
    * Set the token representing the 'while' keyword to the given token.
    *
    * @param whileKeyword the token representing the 'while' keyword
    */
   void set whileKeyword(Token whileKeyword2) {
     this._whileKeyword = whileKeyword2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_body, visitor);
     safelyVisitChild(_condition, visitor);
   }
 }
 /**
  * Instances of the class `DoubleLiteral` represent a floating point literal expression.
  *
  * <pre>
  * doubleLiteral ::=
  *     decimalDigit+ ('.' decimalDigit*)? exponent?
@@ skipping 63 matching lines @@
   }
 
   /**
    * Set the value of the literal to the given value.
    *
    * @param value the value of the literal
    */
   void set value(double value2) {
     this._value = value2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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>
@@ skipping 35 matching lines @@
 
   /**
    * Set the token representing the semicolon that marks the end of the function body to the given
    * token.
    *
    * @param semicolon the token representing the semicolon that marks the end of the function body
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 }
 /**
  * Instances of the class `EmptyStatement` represent an empty statement.
  *
  * <pre>
  * emptyStatement ::=
  *     ';'
  * </pre>
  *
@@ skipping 33 matching lines @@
   Token get semicolon => _semicolon;
 
   /**
    * Set the semicolon terminating the statement to the given token.
    *
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 }
 /**
  * Ephemeral identifiers are created as needed to mimic the presence of an empty identifier.
  *
  * @coverage dart.engine.ast
  */
 class EphemeralIdentifier extends SimpleIdentifier {
   EphemeralIdentifier.full(ASTNode parent, int location) : super.full(new Token(TokenType.IDENTIFIER, location)) {
     parent.becomeParentOf(this);
@@ skipping 36 matching lines @@
    */
   ExportDirective({Comment comment, List<Annotation> metadata, Token keyword, StringLiteral libraryUri, List<Combinator> combinators, Token semicolon}) : this.full(comment, metadata, keyword, libraryUri, combinators, semicolon);
   accept(ASTVisitor visitor) => visitor.visitExportDirective(this);
   LibraryElement get uriElement {
     Element element = this.element;
     if (element is ExportElement) {
       return ((element as ExportElement)).exportedLibrary;
     }
     return null;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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.
  *
  * <pre>
  * expression ::=
@@ skipping 251 matching lines @@
   }
 
   /**
    * Set the semicolon terminating the statement to the given token.
    *
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class `ExpressionStatement` wrap an expression as a statement.
  *
  * <pre>
  * expressionStatement ::=
  *     [Expression]? ';'
  * </pre>
@@ skipping 66 matching lines @@
   }
 
   /**
    * Set the semicolon terminating the statement to the given token.
    *
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class `ExtendsClause` represent the "extends" clause in a class
  * declaration.
  *
  * <pre>
  * extendsClause ::=
  *     'extends' [TypeName]
@@ skipping 59 matching lines @@
   }
 
   /**
    * 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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>
  * fieldDeclaration ::=
  *     'static'? [VariableDeclarationList] ';'
@@ skipping 95 matching lines @@
   }
 
   /**
    * Set the semicolon terminating the declaration to the given token.
    *
    * @param semicolon the semicolon terminating the declaration
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_fieldList, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_staticKeyword != null) {
       return _staticKeyword;
     }
     return _fieldList.beginToken;
   }
 }
@@ skipping 161 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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.
  *
  * <pre>
@@ skipping 179 matching lines @@
   }
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param rightParenthesis the right parenthesis
    */
   void set rightParenthesis(Token rightParenthesis2) {
     this._rightParenthesis = rightParenthesis2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_loopVariable, visitor);
     safelyVisitChild(_iterator, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class `ForStatement` represent a for statement.
  *
  * <pre>
  * forStatement ::=
@@ skipping 257 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_variableList, visitor);
     safelyVisitChild(_initialization, visitor);
     safelyVisitChild(_condition, visitor);
     _updaters.accept(visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * The abstract class `FormalParameter` defines the behavior of objects representing a
  * parameter to a function.
@@ skipping 229 matching lines @@
   }
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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>
  * functionBody ::=
  *     [BlockFunctionBody]
@@ skipping 171 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_functionExpression, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_externalKeyword != null) {
       return _externalKeyword;
     }
     if (_returnType != null) {
@@ skipping 46 matching lines @@
   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 functionDeclaration2) {
     this._functionDeclaration = becomeParentOf(functionDeclaration2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_functionDeclaration, visitor);
   }
 }
 /**
  * Instances of the class `FunctionExpression` represent a function expression.
  *
  * <pre>
  * functionExpression ::=
  *     [FormalParameterList] [FunctionBody]
  * </pre>
@@ skipping 95 matching lines @@
   }
 
   /**
    * 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 parameters2) {
     this._parameters = becomeParentOf(parameters2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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
  * getters and setters are represented by either [PrefixedIdentifier] or
  * [PropertyAccess] nodes.
@@ skipping 131 matching lines @@
 
   /**
    * Set the element associated with the function being invoked based on static type information to
    * the given element.
    *
    * @param element the element to be associated with the function
    */
   void set staticElement(ExecutableElement element) {
     this._staticElement = element;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_function, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class `FunctionTypeAlias` represent a function type alias.
  *
  * <pre>
  * functionTypeAlias ::=
  *      functionPrefix [TypeParameterList]? [FormalParameterList] ';'
@@ skipping 121 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 typeParameters2) {
     this._typeParameters = becomeParentOf(typeParameters2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeParameters, visitor);
     safelyVisitChild(_parameters, visitor);
   }
 }
 /**
  * Instances of the class `FunctionTypedFormalParameter` represent a function-typed formal
  * parameter.
@@ skipping 79 matching lines @@
   }
 
   /**
    * Set the return type of the function to the given type.
    *
    * @param returnType the return type of the function
    */
   void set returnType(TypeName returnType2) {
     this._returnType = becomeParentOf(returnType2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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
  * being imported to those that are not in a given list.
  *
@@ skipping 31 matching lines @@
   HideCombinator({Token keyword, List<SimpleIdentifier> hiddenNames}) : this.full(keyword, hiddenNames);
   accept(ASTVisitor visitor) => visitor.visitHideCombinator(this);
   Token get endToken => _hiddenNames.endToken;
 
   /**
    * Return the list of names from the library that are hidden by this combinator.
    *
    * @return the list of names from the library that are hidden by this combinator
    */
   NodeList<SimpleIdentifier> get hiddenNames => _hiddenNames;
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     _hiddenNames.accept(visitor);
   }
 }
 /**
  * The abstract class `Identifier` defines the behavior common to nodes that represent an
  * identifier.
  *
  * <pre>
  * identifier ::=
  *     [SimpleIdentifier]
@@ skipping 250 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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.
  *
  * <pre>
@@ skipping 53 matching lines @@
   Token get keyword => _keyword;
 
   /**
    * Set the token representing the 'implements' keyword to the given token.
    *
    * @param keyword the token representing the 'implements' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     _interfaces.accept(visitor);
   }
 }
 /**
  * Instances of the class `ImportDirective` represent an import directive.
  *
  * <pre>
  * importDirective ::=
  *     [Annotation] 'import' [StringLiteral] ('as' identifier)? [Combinator]* ';'
  * </pre>
@@ skipping 78 matching lines @@
   }
 
   /**
    * 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 prefix2) {
     this._prefix = becomeParentOf(prefix2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
     combinators.accept(visitor);
   }
 }
 /**
  * Instances of the class `IndexExpression` represent an index expression.
  *
  * <pre>
  * indexExpression ::=
@@ skipping 39 matching lines @@
   MethodElement _staticElement;
 
   /**
    * 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.
    */
   MethodElement _propagatedElement;
 
   /**
+   * If this expression is both in a getter and setter context, the [AuxiliaryElements] will
+   * be set to hold onto the static and propagated information. The auxiliary element will hold onto
+   * the elements from the getter context.
+   */
+  AuxiliaryElements _auxiliaryElements = null;
+
+  /**
    * Initialize a newly created index expression.
    *
    * @param target the expression used to compute the object being indexed
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
   IndexExpression.forTarget_full(Expression target, Token leftBracket, Expression index, Token rightBracket) {
     this._target = becomeParentOf(target);
     this._leftBracket = leftBracket;
@@ skipping 29 matching lines @@
   /**
    * Initialize a newly created index expression.
    *
    * @param period the period ("..") before a cascaded index expression
    * @param leftBracket the left square bracket
    * @param index the expression used to compute the index
    * @param rightBracket the right square bracket
    */
   IndexExpression.forCascade({Token period, Token leftBracket, Expression index, Token rightBracket}) : this.forCascade_full(period, leftBracket, index, rightBracket);
   accept(ASTVisitor visitor) => visitor.visitIndexExpression(this);
+
+  /**
+   * Get the auxiliary elements, this will be `null` if the node is not in a getter and setter
+   * context, or if it is not yet fully resolved.
+   */
+  AuxiliaryElements get auxiliaryElements => _auxiliaryElements;
   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
@@ skipping 138 matching lines @@
   /**
    * 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;
 
   /**
+   * Set the auxiliary elements.
+   */
+  void set auxiliaryElements(AuxiliaryElements auxiliaryElements2) {
+    this._auxiliaryElements = auxiliaryElements2;
+  }
+
+  /**
    * Set the expression used to compute the index to the given expression.
    *
    * @param expression the expression used to compute the index
    */
   void set index(Expression expression) {
     _index = becomeParentOf(expression);
   }
 
   /**
    * Set the left square bracket to the given token.
@@ skipping 43 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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`.
    *
    * This method is only intended to be used by [Expression#getPropagatedParameterElement].
@@ skipping 184 matching lines @@
 
   /**
    * Set the element associated with the constructor based on static type information to the given
    * element.
    *
    * @param element the element to be associated with the constructor
    */
   void set staticElement(ConstructorElement element) {
     this._staticElement = element;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class `IntegerLiteral` represent an integer literal expression.
  *
  * <pre>
  * integerLiteral ::=
  *     decimalIntegerLiteral
@@ skipping 67 matching lines @@
   }
 
   /**
    * Set the value of the literal to the given value.
    *
    * @param value the value of the literal
    */
   void set value(int value2) {
     this._value = value2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 }
 /**
  * The abstract class `InterpolationElement` defines the behavior common to elements within a
  * [StringInterpolation].
  *
  * <pre>
  * interpolationElement ::=
  *     [InterpolationExpression]
  *   | [InterpolationString]
@@ skipping 104 matching lines @@
   }
 
   /**
    * Set the right curly bracket to the given token.
    *
    * @param rightBracket the right curly bracket
    */
   void set rightBracket(Token rightBracket2) {
     this._rightBracket = rightBracket2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class `InterpolationString` represent a non-empty substring of an
  * interpolated string.
  *
  * <pre>
  * interpolationString ::=
  *     characters
@@ skipping 59 matching lines @@
   }
 
   /**
    * Set the value of the literal to the given string.
    *
    * @param string the value of the literal
    */
   void set value(String string) {
     _value = string;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 }
 /**
  * Instances of the class `IsExpression` represent an is expression.
  *
  * <pre>
  * isExpression ::=
  *     [Expression] 'is' '!'? [TypeName]
  * </pre>
  *
@@ skipping 106 matching lines @@
   }
 
   /**
    * 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     safelyVisitChild(_type, visitor);
   }
 }
 /**
  * Instances of the class `Label` represent a label.
  *
  * <pre>
  * label ::=
  *     [SimpleIdentifier] ':'
@@ skipping 59 matching lines @@
   }
 
   /**
    * 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 label2) {
     this._label = becomeParentOf(label2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_label, visitor);
   }
 }
 /**
  * Instances of the class `LabeledStatement` represent a statement that has a label associated
  * with them.
  *
  * <pre>
  * labeledStatement ::=
  *    [Label]+ [Statement]
@@ skipping 56 matching lines @@
   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 statement2) {
     this._statement = becomeParentOf(statement2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     _labels.accept(visitor);
     safelyVisitChild(_statement, visitor);
   }
 }
 /**
  * Instances of the class `LibraryDirective` represent a library directive.
  *
  * <pre>
  * libraryDirective ::=
  *     [Annotation] 'library' [Identifier] ';'
@@ skipping 87 matching lines @@
   }
 
   /**
    * Set the semicolon terminating the directive to the given token.
    *
    * @param semicolon the semicolon terminating the directive
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _libraryToken;
 }
 /**
  * Instances of the class `LibraryIdentifier` represent the identifier for a library.
  *
  * <pre>
  * libraryIdentifier ::=
@@ skipping 44 matching lines @@
         builder.append(".");
       } else {
         needsPeriod = true;
       }
       builder.append(identifier.name);
     }
     return builder.toString();
   }
   Element get propagatedElement => null;
   Element get staticElement => null;
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     _components.accept(visitor);
   }
 }
 /**
  * Instances of the class `ListLiteral` represent a list literal.
  *
  * <pre>
  * listLiteral ::=
  *     'const'? ('<' [TypeName] '>')? '[' ([Expression] ','?)? ']'
  * </pre>
@@ skipping 90 matching lines @@
   }
 
   /**
    * Set the right square bracket to the given token.
    *
    * @param bracket the right square bracket
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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 ::=
@@ skipping 110 matching lines @@
   }
 
   /**
    * Set the right curly bracket to the given token.
    *
    * @param bracket the right curly bracket
    */
   void set rightBracket(Token bracket) {
     _rightBracket = bracket;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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.
  *
  * <pre>
  * mapLiteralEntry ::=
@@ skipping 86 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_key, visitor);
     safelyVisitChild(_value, visitor);
   }
 }
 /**
  * Instances of the class `MethodDeclaration` represent a method declaration.
  *
  * <pre>
  * methodDeclaration ::=
  *     methodSignature [FunctionBody]
@@ skipping 269 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_returnType, visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_parameters, visitor);
     safelyVisitChild(_body, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_modifierKeyword != null) {
       return _modifierKeyword;
     } else if (_returnType != null) {
@@ skipping 171 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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.
  *
  * <pre>
@@ skipping 76 matching lines @@
   }
 
   /**
    * 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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.
  *
  * <pre>
  * directive ::=
@@ skipping 154 matching lines @@
   }
 
   /**
    * Sets the name of the native object that implements the class.
    *
    * @param name the name of the native object that implements the class.
    */
   void set name(StringLiteral name2) {
     this._name = name2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_name, visitor);
   }
 }
 /**
  * Instances of the class `NativeFunctionBody` represent a function body that consists of a
  * native keyword followed by a string literal.
  *
  * <pre>
  * nativeFunctionBody ::=
  *     'native' [SimpleStringLiteral] ';'
@@ skipping 58 matching lines @@
    * @return the token representing the semicolon that marks the end of the function body
    */
   Token get semicolon => _semicolon;
 
   /**
    * Return the string literal representing the string after the 'native' token.
    *
    * @return the string literal representing the string after the 'native' token
    */
   StringLiteral get stringLiteral => _stringLiteral;
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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>
  * normalFormalParameter ::=
  *     [FunctionTypedFormalParameter]
@@ skipping 77 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 identifier2) {
     this._identifier = becomeParentOf(identifier2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     if (commentIsBeforeAnnotations()) {
       safelyVisitChild(_comment, visitor);
       _metadata.accept(visitor);
     } else {
       for (ASTNode child in sortedCommentAndAnnotations) {
         child.accept(visitor);
       }
     }
   }
 
@@ skipping 70 matching lines @@
   Token get literal => _literal;
 
   /**
    * Set the token representing the literal to the given token.
    *
    * @param literal the token representing the literal
    */
   void set literal(Token literal2) {
     this._literal = literal2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 }
 /**
  * Instances of the class `ParenthesizedExpression` represent a parenthesized expression.
  *
  * <pre>
  * parenthesizedExpression ::=
  *     '(' [Expression] ')'
  * </pre>
  *
@@ skipping 81 matching lines @@
   }
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param parenthesis the right parenthesis
    */
   void set rightParenthesis(Token parenthesis) {
     _rightParenthesis = parenthesis;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
   }
 }
 /**
  * Instances of the class `PartDirective` represent a part directive.
  *
  * <pre>
  * partDirective ::=
  *     [Annotation] 'part' [StringLiteral] ';'
  * </pre>
@@ skipping 194 matching lines @@
   }
 
   /**
    * Set the semicolon terminating the directive to the given token.
    *
    * @param semicolon the semicolon terminating the directive
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_libraryName, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _partToken;
 }
 /**
  * Instances of the class `PostfixExpression` represent a postfix unary expression.
  *
  * <pre>
  * postfixExpression ::=
@@ skipping 130 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;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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 170 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;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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 146 matching lines @@
 
   /**
    * 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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
  * [PrefixedIdentifier] nodes in cases where the target is also a simple
  * identifier.
@@ skipping 128 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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.
  *
  * <pre>
  * redirectingConstructorInvocation ::=
@@ skipping 166 matching lines @@
 
   /**
    * Set the element associated with the constructor based on static type information to the given
    * element.
    *
    * @param element the element to be associated with the constructor
    */
   void set staticElement(ConstructorElement element) {
     this._staticElement = element;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class `RethrowExpression` represent a rethrow expression.
  *
  * <pre>
  * rethrowExpression ::=
  *     'rethrow'
@@ skipping 35 matching lines @@
   Token get keyword => _keyword;
 
   /**
    * Set the token representing the 'rethrow' keyword to the given token.
    *
    * @param keyword the token representing the 'rethrow' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 }
 /**
  * Instances of the class `ReturnStatement` represent a return statement.
  *
  * <pre>
  * returnStatement ::=
  *     'return' [Expression]? ';'
  * </pre>
  *
@@ skipping 83 matching lines @@
   }
 
   /**
    * Set the semicolon terminating the statement to the given token.
    *
    * @param semicolon the semicolon terminating the statement
    */
   void set semicolon(Token semicolon2) {
     this._semicolon = semicolon2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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
@@ skipping 35 matching lines @@
   Token get scriptTag => _scriptTag;
 
   /**
    * Set the token representing this script tag to the given script tag.
    *
    * @param scriptTag the token representing this script tag
    */
   void set scriptTag(Token scriptTag2) {
     this._scriptTag = scriptTag2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 }
 /**
  * Instances of the class `ShowCombinator` represent a combinator that restricts the names
  * being imported to those in a given list.
  *
  * <pre>
  * showCombinator ::=
  *     'show' [SimpleIdentifier] (',' [SimpleIdentifier])*
  * </pre>
@@ skipping 27 matching lines @@
   ShowCombinator({Token keyword, List<SimpleIdentifier> shownNames}) : this.full(keyword, shownNames);
   accept(ASTVisitor visitor) => visitor.visitShowCombinator(this);
   Token get endToken => _shownNames.endToken;
 
   /**
    * Return the list of names from the library that are made visible by this combinator.
    *
    * @return the list of names from the library that are made visible by this combinator
    */
   NodeList<SimpleIdentifier> get shownNames => _shownNames;
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     _shownNames.accept(visitor);
   }
 }
 /**
  * Instances of the class `SimpleFormalParameter` represent a simple formal parameter.
  *
  * <pre>
  * simpleFormalParameter ::=
  *     ('final' [TypeName] | 'var' | [TypeName])? [SimpleIdentifier]
  * </pre>
@@ skipping 76 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_type, visitor);
     safelyVisitChild(identifier, visitor);
   }
 }
 /**
  * Instances of the class `SimpleIdentifier` represent a simple identifier.
  *
  * <pre>
  * simpleIdentifier ::=
@@ skipping 20 matching lines @@
   Element _staticElement;
 
   /**
    * The element associated with this identifier based on propagated type information, or
    * `null` if the AST structure has not been resolved or if this identifier could not be
    * resolved.
    */
   Element _propagatedElement;
 
   /**
+   * If this expression is both in a getter and setter context, the [AuxiliaryElements] will
+   * be set to hold onto the static and propagated information. The auxiliary element will hold onto
+   * the elements from the getter context.
+   */
+  AuxiliaryElements _auxiliaryElements = null;
+
+  /**
    * Initialize a newly created identifier.
    *
    * @param token the token representing the identifier
    */
   SimpleIdentifier.full(Token token) {
     this._token = token;
   }
 
   /**
    * Initialize a newly created identifier.
    *
    * @param token the token representing the identifier
    */
   SimpleIdentifier({Token token}) : this.full(token);
   accept(ASTVisitor visitor) => visitor.visitSimpleIdentifier(this);
+
+  /**
+   * Get the auxiliary elements, this will be `null` if the node is not in a getter and setter
+   * context, or if it is not yet fully resolved.
+   */
+  AuxiliaryElements get auxiliaryElements => _auxiliaryElements;
   Token get beginToken => _token;
   Element get bestElement {
     if (_propagatedElement == null) {
       return _staticElement;
     }
     return _propagatedElement;
   }
   Token get endToken => _token;
   String get name => _token.lexeme;
   Element get propagatedElement => _propagatedElement;
@@ skipping 113 matching lines @@
     } else if (parent is PostfixExpression) {
       return true;
     } else if (parent is AssignmentExpression) {
       return identical(((parent as AssignmentExpression)).leftHandSide, target);
     }
     return false;
   }
   bool get isSynthetic => _token.isSynthetic;
 
   /**
+   * Set the auxiliary elements.
+   */
+  void set auxiliaryElements(AuxiliaryElements auxiliaryElements2) {
+    this._auxiliaryElements = auxiliaryElements2;
+  }
+
+  /**
    * 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 = validateElement2(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 = validateElement2(element);
   }
 
   /**
    * Set the token representing the identifier to the given token.
    *
    * @param token the token representing the literal
    */
   void set token(Token token2) {
     this._token = token2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 
   /**
    * Return the given element if it is an appropriate element based on the parent of this
    * identifier, or `null` if it is not appropriate.
    *
    * @param element the element to be associated with this identifier
    * @return the element to be associated with this identifier
    */
   Element validateElement(ASTNode parent, Type expectedClass, Element element) {
@@ skipping 143 matching lines @@
   }
 
   /**
    * 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
   void appendStringValue(JavaStringBuilder builder) {
     builder.append(value);
   }
 }
 /**
  * Instances of the class `Statement` defines the behavior common to nodes that represent a
  * statement.
  *
  * <pre>
@@ skipping 55 matching lines @@
   accept(ASTVisitor visitor) => visitor.visitStringInterpolation(this);
   Token get beginToken => _elements.beginToken;
 
   /**
    * Return the elements that will be composed to produce the resulting string.
    *
    * @return the elements that will be composed to produce the resulting string
    */
   NodeList<InterpolationElement> get elements => _elements;
   Token get endToken => _elements.endToken;
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     _elements.accept(visitor);
   }
   void appendStringValue(JavaStringBuilder builder) {
     throw new IllegalArgumentException();
   }
 }
 /**
  * Instances of the class `StringLiteral` represent a string literal expression.
  *
  * <pre>
@@ skipping 206 matching lines @@
 
   /**
    * Set the element associated with the constructor based on static type information to the given
    * element.
    *
    * @param element the element to be associated with the constructor
    */
   void set staticElement(ConstructorElement element) {
     this._staticElement = element;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_constructorName, visitor);
     safelyVisitChild(_argumentList, visitor);
   }
 }
 /**
  * Instances of the class `SuperExpression` represent a super expression.
  *
  * <pre>
  * superExpression ::=
  *     'super'
@@ skipping 35 matching lines @@
   Token get keyword => _keyword;
 
   /**
    * Set the token representing the keyword to the given token.
    *
    * @param keyword the token representing the keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 }
 /**
  * Instances of the class `SwitchCase` represent the case in a switch statement.
  *
  * <pre>
  * switchCase ::=
  *     [SimpleIdentifier]* 'case' [Expression] ':' [Statement]*
  * </pre>
  *
@@ skipping 39 matching lines @@
   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 expression2) {
     this._expression = becomeParentOf(expression2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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 ::=
@@ skipping 17 matching lines @@
   /**
    * Initialize a newly created switch default.
    *
    * @param labels the labels associated with the switch member
    * @param keyword the token representing the 'case' or 'default' keyword
    * @param colon the colon separating the keyword or the expression from the statements
    * @param statements the statements that will be executed if this switch member is selected
    */
   SwitchDefault({List<Label> labels, Token keyword, Token colon, List<Statement> statements}) : this.full(labels, keyword, colon, statements);
   accept(ASTVisitor visitor) => visitor.visitSwitchDefault(this);
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     labels.accept(visitor);
     statements.accept(visitor);
   }
 }
 /**
  * The abstract class `SwitchMember` defines the behavior common to objects representing
  * elements within a switch statement.
  *
  * <pre>
  * switchMember ::=
@@ skipping 291 matching lines @@
   }
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param rightParenthesis the right parenthesis
    */
   void set rightParenthesis(Token rightParenthesis2) {
     this._rightParenthesis = rightParenthesis2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_expression, visitor);
     _members.accept(visitor);
   }
 }
 /**
  * Instances of the class `SymbolLiteral` represent a symbol literal expression.
  *
  * <pre>
  * symbolLiteral ::=
  *     '#' (operator | (identifier ('.' identifier)*))
@@ skipping 50 matching lines @@
   Token get poundSign => _poundSign;
 
   /**
    * Set the token introducing the literal to the given token.
    *
    * @param poundSign the token introducing the literal
    */
   void set poundSign(Token poundSign2) {
     this._poundSign = poundSign2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 }
 /**
  * Instances of the class `ThisExpression` represent a this expression.
  *
  * <pre>
  * thisExpression ::=
  *     'this'
  * </pre>
  *
@@ skipping 33 matching lines @@
   Token get keyword => _keyword;
 
   /**
    * Set the token representing the keyword to the given token.
    *
    * @param keyword the token representing the keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
   }
 }
 /**
  * Instances of the class `ThrowExpression` represent a throw expression.
  *
  * <pre>
  * throwExpression ::=
  *     'throw' [Expression]
  * </pre>
  *
@@ skipping 62 matching lines @@
   }
 
   /**
    * Set the token representing the 'throw' keyword to the given token.
    *
    * @param keyword the token representing the 'throw' keyword
    */
   void set keyword(Token keyword2) {
     this._keyword = keyword2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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>
  * topLevelVariableDeclaration ::=
  *     ('final' | 'const') type? staticFinalDeclarationList ';'
@@ skipping 64 matching lines @@
   }
 
   /**
    * 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_variableList, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
 }
 /**
  * Instances of the class `TryStatement` represent a try statement.
  *
  * <pre>
  * tryStatement ::=
@@ skipping 140 matching lines @@
   }
 
   /**
    * Set the token representing the 'try' keyword to the given token.
    *
    * @param tryKeyword the token representing the 'try' keyword
    */
   void set tryKeyword(Token tryKeyword2) {
     this._tryKeyword = tryKeyword2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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.
  *
  * <pre>
  * typeAlias ::=
@@ skipping 159 matching lines @@
   }
 
   /**
    * Set the right bracket to the given token.
    *
    * @param rightBracket the right bracket
    */
   void set rightBracket(Token rightBracket2) {
     this._rightBracket = rightBracket2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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>
  * typeName ::=
  *     [Identifier] typeArguments?
@@ skipping 89 matching lines @@
   }
 
   /**
    * 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 typeArguments2) {
     this._typeArguments = becomeParentOf(typeArguments2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_typeArguments, visitor);
   }
 }
 /**
  * Instances of the class `TypeParameter` represent a type parameter.
  *
  * <pre>
  * typeParameter ::=
  *     [SimpleIdentifier] ('extends' [TypeName])?
@@ skipping 96 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_bound, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 /**
  * Instances of the class `TypeParameterList` represent type parameters within a declaration.
  *
  * <pre>
@@ skipping 59 matching lines @@
    * @return the right angle bracket
    */
   Token get rightBracket => _rightBracket;
 
   /**
    * Return the type parameters for the type.
    *
    * @return the type parameters for the type
    */
   NodeList<TypeParameter> get typeParameters => _typeParameters;
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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>
  * listLiteral ::=
  *     [ListLiteral]
@@ skipping 61 matching lines @@
   }
 
   /**
    * Set the type argument associated with this literal to the given arguments.
    *
    * @param typeArguments the type argument associated with this literal
    */
   void set typeArguments(TypeArgumentList typeArguments2) {
     this._typeArguments = typeArguments2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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>
  * uriBasedDirective ::=
  *     [ExportDirective]
@@ skipping 47 matching lines @@
   Element get uriElement;
 
   /**
    * Set the URI referenced by this directive to the given URI.
    *
    * @param uri the URI referenced by this directive
    */
   void set uri(StringLiteral uri2) {
     this._uri = becomeParentOf(uri2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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].
  *
  * <pre>
@@ skipping 137 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 name2) {
     this._name = becomeParentOf(name2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_name, visitor);
     safelyVisitChild(_initializer, visitor);
   }
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 }
 /**
  * Instances of the class `VariableDeclarationList` represent the declaration of one or more
  * variables of the same type.
  *
@@ skipping 105 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);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_type, visitor);
     _variables.accept(visitor);
   }
   Token get firstTokenAfterCommentAndMetadata {
     if (_keyword != null) {
       return _keyword;
     } else if (_type != null) {
       return _type.beginToken;
     }
     return _variables.beginToken;
@@ skipping 68 matching lines @@
   }
 
   /**
    * Set the variables being declared to the given list of variables.
    *
    * @param variableList the variables being declared
    */
   void set variables(VariableDeclarationList variableList2) {
     this._variableList = becomeParentOf(variableList2);
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_variableList, visitor);
   }
 }
 /**
  * Instances of the class `WhileStatement` represent a while statement.
  *
  * <pre>
  * whileStatement ::=
  *     'while' '(' [Expression] ')' [Statement]
  * </pre>
@@ skipping 131 matching lines @@
   }
 
   /**
    * Set the right parenthesis to the given token.
    *
    * @param rightParenthesis the right parenthesis
    */
   void set rightParenthesis(Token rightParenthesis2) {
     this._rightParenthesis = rightParenthesis2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  void visitChildren(ASTVisitor visitor) {
     safelyVisitChild(_condition, visitor);
     safelyVisitChild(_body, visitor);
   }
 }
 /**
  * Instances of the class `WithClause` represent the with clause in a class declaration.
  *
  * <pre>
  * withClause ::=
  *     'with' [TypeName] (',' [TypeName])*
@@ skipping 51 matching lines @@
   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 withKeyword2) {
     this._withKeyword = withKeyword2;
   }
-  void visitChildren(ASTVisitor<Object> visitor) {
+  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].
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or
@@ skipping 143 matching lines @@
       } else if (node.operator.type == TokenType.BAR_BAR) {
         if (leftOperand is bool && rightOperand is bool) {
           return ((leftOperand as bool)) || ((rightOperand as bool));
         }
       } else if (node.operator.type == TokenType.CARET) {
         if (leftOperand is int && rightOperand is int) {
           return ((leftOperand as int)) ^ (rightOperand as int);
         }
       } else if (node.operator.type == TokenType.EQ_EQ) {
         if (leftOperand is bool && rightOperand is bool) {
-          return identical(((leftOperand as bool)), ((rightOperand as bool)));
+          return identical(leftOperand as bool, rightOperand as bool);
         } else if (leftOperand is int && rightOperand is int) {
           return ((leftOperand as int)) == rightOperand;
         } else if (leftOperand is double && rightOperand is double) {
           return ((leftOperand as double)) == rightOperand;
         } else if (leftOperand is String && rightOperand is String) {
           return ((leftOperand as String)) == rightOperand;
         }
       } else if (node.operator.type == TokenType.GT) {
         if (leftOperand is int && rightOperand is int) {
-          return ((leftOperand as int)).compareTo((rightOperand as int)) > 0;
+          return ((leftOperand as int)).compareTo(rightOperand as int) > 0;
         } else if (leftOperand is double && rightOperand is double) {
-          return ((leftOperand as double)).compareTo((rightOperand as double)) > 0;
+          return ((leftOperand as double)).compareTo(rightOperand as double) > 0;
         }
       } else if (node.operator.type == TokenType.GT_EQ) {
         if (leftOperand is int && rightOperand is int) {
-          return ((leftOperand as int)).compareTo((rightOperand as int)) >= 0;
+          return ((leftOperand as int)).compareTo(rightOperand as int) >= 0;
         } else if (leftOperand is double && rightOperand is double) {
-          return ((leftOperand as double)).compareTo((rightOperand as double)) >= 0;
+          return ((leftOperand as double)).compareTo(rightOperand as double) >= 0;
         }
       } else if (node.operator.type == TokenType.GT_GT) {
         if (leftOperand is int && rightOperand is int) {
           return ((leftOperand as int)) >> ((rightOperand as int));
         }
       } else if (node.operator.type == TokenType.LT) {
         if (leftOperand is int && rightOperand is int) {
-          return ((leftOperand as int)).compareTo((rightOperand as int)) < 0;
+          return ((leftOperand as int)).compareTo(rightOperand as int) < 0;
         } else if (leftOperand is double && rightOperand is double) {
-          return ((leftOperand as double)).compareTo((rightOperand as double)) < 0;
+          return ((leftOperand as double)).compareTo(rightOperand as double) < 0;
         }
       } else if (node.operator.type == TokenType.LT_EQ) {
         if (leftOperand is int && rightOperand is int) {
-          return ((leftOperand as int)).compareTo((rightOperand as int)) <= 0;
+          return ((leftOperand as int)).compareTo(rightOperand as int) <= 0;
         } else if (leftOperand is double && rightOperand is double) {
-          return ((leftOperand as double)).compareTo((rightOperand as double)) <= 0;
+          return ((leftOperand as double)).compareTo(rightOperand as double) <= 0;
         }
       } else if (node.operator.type == TokenType.LT_LT) {
         if (leftOperand is int && rightOperand is int) {
           return ((leftOperand as int)) << ((rightOperand as int));
         }
       } else if (node.operator.type == TokenType.MINUS) {
         if (leftOperand is int && rightOperand is int) {
           return ((leftOperand as int)) - (rightOperand as int);
         } else if (leftOperand is double && rightOperand is double) {
           return ((leftOperand as double)) - ((rightOperand as double));
         }
       } else if (node.operator.type == TokenType.PERCENT) {
         if (leftOperand is int && rightOperand is int) {
-          return ((leftOperand as int)).remainder((rightOperand as int));
+          return ((leftOperand as int)).remainder(rightOperand as int);
         } else if (leftOperand is double && rightOperand is double) {
           return ((leftOperand as double)) % ((rightOperand as double));
         }
       } else if (node.operator.type == TokenType.PLUS) {
         if (leftOperand is int && rightOperand is int) {
           return ((leftOperand as int)) + (rightOperand as int);
         } else if (leftOperand is double && rightOperand is double) {
           return ((leftOperand as double)) + ((rightOperand as double));
         }
       } else if (node.operator.type == TokenType.STAR) {
@@ skipping 1997 matching lines @@
   WithClause visitWithClause(WithClause node) => new WithClause.full(node.withKeyword, clone3(node.mixinTypes));
   ASTNode clone2(ASTNode node) {
     if (node == null) {
       return null;
     }
     return node.accept(this) as ASTNode;
   }
   List clone3(NodeList nodes) {
     List clonedNodes = new List();
     for (ASTNode node in nodes) {
-      clonedNodes.add((node.accept(this) as ASTNode));
+      clonedNodes.add(node.accept(this) as ASTNode);
     }
     return clonedNodes;
   }
 }
 /**
  * Traverse the AST from initial child node to successive parents, building a collection of local
  * variable and parameter names visible to the initial child node. In case of name shadowing, the
  * first name seen is the most specific one so names are not redefined.
  *
  * Completion test code coverage is 95%. The two basic blocks that are not executed cannot be
@@ skipping 192 matching lines @@
     return elements[elements.length - 1].endToken;
   }
   /**
    * Return the node that is the parent of each of the elements in the list.
    * @return the node that is the parent of each of the elements in the list
    */
   ASTNode getOwner() {
     return owner;
   }
 }