Remove cast from AstNodeImpl._becomeParentOf

pkg/analyzer/lib/src/dart/ast/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.
 
 library analyzer.src.dart.ast.ast;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 78 matching lines @@
   /**
    * The annotations associated with this node.
    */
   NodeList<Annotation> _metadata;
 
   /**
    * Initialize a newly created annotated node. Either or both of the [comment]
    * and [metadata] can be `null` if the node does not have the corresponding
    * attribute.
    */
-  AnnotatedNodeImpl(Comment comment, List<Annotation> metadata) {
+  AnnotatedNodeImpl(CommentImpl comment, List<Annotation> metadata) {
     _comment = _becomeParentOf(comment);
     _metadata = new NodeListImpl<Annotation>(this, metadata);
   }
 
   @override
   Token get beginToken {
     if (_comment == null) {
       if (_metadata.isEmpty) {
         return firstTokenAfterCommentAndMetadata;
       }
       return _metadata.beginToken;
     } else if (_metadata.isEmpty) {
       return _comment.beginToken;
     }
     Token commentToken = _comment.beginToken;
     Token metadataToken = _metadata.beginToken;
     if (commentToken.offset < metadataToken.offset) {
       return commentToken;
     }
     return metadataToken;
   }
 
   @override
   Comment get documentationComment => _comment;
 
   @override
   void set documentationComment(Comment comment) {
-    _comment = _becomeParentOf(comment);
+    _comment = _becomeParentOf(comment as AstNodeImpl);
   }
 
   @override
   NodeList<Annotation> get metadata => _metadata;
 
   @override
   List<AstNode> get sortedCommentAndAnnotations {
     return <AstNode>[]
       ..add(_comment)
       ..addAll(_metadata)
@@ skipping 93 matching lines @@
    */
   @override
   ElementAnnotation elementAnnotation;
 
   /**
    * Initialize a newly created annotation. Both the [period] and the
    * [constructorName] can be `null` if the annotation is not referencing a
    * named constructor. The [arguments] can be `null` if the annotation is not
    * referencing a constructor.
    */
-  AnnotationImpl(this.atSign, Identifier name, this.period,
-      SimpleIdentifier constructorName, ArgumentList arguments) {
+  AnnotationImpl(this.atSign, IdentifierImpl name, this.period,
+      SimpleIdentifierImpl constructorName, ArgumentListImpl arguments) {
     _name = _becomeParentOf(name);
     _constructorName = _becomeParentOf(constructorName);
     _arguments = _becomeParentOf(arguments);
   }
 
   @override
   ArgumentList get arguments => _arguments;
 
   @override
   void set arguments(ArgumentList arguments) {
-    _arguments = _becomeParentOf(arguments);
+    _arguments = _becomeParentOf(arguments as AstNodeImpl);
   }
 
   @override
   Token get beginToken => atSign;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(atSign)
     ..add(_name)
     ..add(period)
     ..add(_constructorName)
     ..add(_arguments);
 
   @override
   SimpleIdentifier get constructorName => _constructorName;
 
   @override
   void set constructorName(SimpleIdentifier name) {
-    _constructorName = _becomeParentOf(name);
+    _constructorName = _becomeParentOf(name as AstNodeImpl);
   }
 
   @override
   Element get element {
     if (_element != null) {
       return _element;
     } else if (_name != null) {
       return _name.staticElement;
     }
     return null;
@@ skipping 12 matching lines @@
       return _constructorName.endToken;
     }
     return _name.endToken;
   }
 
   @override
   Identifier get name => _name;
 
   @override
   void set name(Identifier name) {
-    _name = _becomeParentOf(name);
+    _name = _becomeParentOf(name as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitAnnotation(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _name?.accept(visitor);
     _constructorName?.accept(visitor);
@@ skipping 176 matching lines @@
   Token asOperator;
 
   /**
    * The name of the type being cast to.
    */
   TypeName _type;
 
   /**
    * Initialize a newly created as expression.
    */
-  AsExpressionImpl(Expression expression, this.asOperator, TypeName type) {
+  AsExpressionImpl(
+      ExpressionImpl expression, this.asOperator, TypeNameImpl type) {
     _expression = _becomeParentOf(expression);
     _type = _becomeParentOf(type);
   }
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_expression)..add(asOperator)..add(_type);
 
   @override
   Token get endToken => _type.endToken;
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => 7;
 
   @override
   TypeName get type => _type;
 
   @override
   void set type(TypeName name) {
-    _type = _becomeParentOf(name);
+    _type = _becomeParentOf(name as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitAsExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _expression?.accept(visitor);
     _type?.accept(visitor);
@@ skipping 47 matching lines @@
    */
   @override
   Token semicolon;
 
   /**
    * Initialize a newly created assert statement.
    */
   AssertStatementImpl(
       this.assertKeyword,
       this.leftParenthesis,
-      Expression condition,
+      ExpressionImpl condition,
       this.comma,
-      Expression message,
+      ExpressionImpl message,
       this.rightParenthesis,
       this.semicolon) {
     _condition = _becomeParentOf(condition);
     _message = _becomeParentOf(message);
   }
 
   @override
   Token get beginToken => assertKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(assertKeyword)
     ..add(leftParenthesis)
     ..add(_condition)
     ..add(comma)
     ..add(_message)
     ..add(rightParenthesis)
     ..add(semicolon);
 
   @override
   Expression get condition => _condition;
 
   @override
   void set condition(Expression condition) {
-    _condition = _becomeParentOf(condition);
+    _condition = _becomeParentOf(condition as AstNodeImpl);
   }
 
   @override
   Token get endToken => semicolon;
 
   @override
   Expression get message => _message;
 
   @override
   void set message(Expression expression) {
-    _message = _becomeParentOf(expression);
+    _message = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitAssertStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _condition?.accept(visitor);
     message?.accept(visitor);
@@ skipping 38 matching lines @@
    * 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.
    */
   @override
   MethodElement propagatedElement;
 
   /**
    * Initialize a newly created assignment expression.
    */
-  AssignmentExpressionImpl(
-      Expression leftHandSide, this.operator, Expression rightHandSide) {
+  AssignmentExpressionImpl(ExpressionImpl leftHandSide, this.operator,
+      ExpressionImpl rightHandSide) {
     if (leftHandSide == null || rightHandSide == null) {
       String message;
       if (leftHandSide == null) {
         if (rightHandSide == null) {
           message = "Both the left-hand and right-hand sides are null";
         } else {
           message = "The left-hand size is null";
         }
       } else {
         message = "The right-hand size is null";
@@ skipping 24 matching lines @@
     ..add(_rightHandSide);
 
   @override
   Token get endToken => _rightHandSide.endToken;
 
   @override
   Expression get leftHandSide => _leftHandSide;
 
   @override
   void set leftHandSide(Expression expression) {
-    _leftHandSide = _becomeParentOf(expression);
+    _leftHandSide = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => 1;
 
   @override
   Expression get rightHandSide => _rightHandSide;
 
   @override
   void set rightHandSide(Expression expression) {
-    _rightHandSide = _becomeParentOf(expression);
+    _rightHandSide = _becomeParentOf(expression as AstNodeImpl);
   }
 
   /**
    * 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`.
    */
   ParameterElement get _propagatedParameterElementForRightHandSide {
     ExecutableElement executableElement = null;
@@ skipping 164 matching lines @@
     accept(new ToSourceVisitor(writer));
     return writer.toString();
   }
 
   @override
   String toString() => toSource();
 
   /**
    * Make this node the parent of the given [child] node. Return the child node.
    */
-  AstNode _becomeParentOf(AstNode child) {
+  AstNode _becomeParentOf(AstNodeImpl child) {
     if (child != null) {
-      (child as AstNodeImpl)._parent = this;
+      child._parent = this;
     }
     return child;
   }
 }
 
 /**
  * An await expression.
  *
  *    awaitExpression ::=
  *        'await' [Expression]
  */
 class AwaitExpressionImpl extends ExpressionImpl implements AwaitExpression {
   /**
    * The 'await' keyword.
    */
   @override
   Token awaitKeyword;
 
   /**
    * The expression whose value is being waited on.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created await expression.
    */
-  AwaitExpressionImpl(this.awaitKeyword, Expression expression) {
+  AwaitExpressionImpl(this.awaitKeyword, ExpressionImpl expression) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken {
     if (awaitKeyword != null) {
       return awaitKeyword;
     }
     return _expression.beginToken;
   }
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(awaitKeyword)..add(_expression);
 
   @override
   Token get endToken => _expression.endToken;
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => 0;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitAwaitExpression(this);
 
   @override
@@ skipping 39 matching lines @@
    * the operator is not user definable, or if the operator could not be
    * resolved.
    */
   @override
   MethodElement propagatedElement;
 
   /**
    * Initialize a newly created binary expression.
    */
   BinaryExpressionImpl(
-      Expression leftOperand, this.operator, Expression rightOperand) {
+      ExpressionImpl leftOperand, this.operator, ExpressionImpl rightOperand) {
     _leftOperand = _becomeParentOf(leftOperand);
     _rightOperand = _becomeParentOf(rightOperand);
   }
 
   @override
   Token get beginToken => _leftOperand.beginToken;
 
   @override
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_leftOperand)..add(operator)..add(_rightOperand);
 
   @override
   Token get endToken => _rightOperand.endToken;
 
   @override
   Expression get leftOperand => _leftOperand;
 
   @override
   void set leftOperand(Expression expression) {
-    _leftOperand = _becomeParentOf(expression);
+    _leftOperand = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => operator.type.precedence;
 
   @override
   Expression get rightOperand => _rightOperand;
 
   @override
   void set rightOperand(Expression expression) {
-    _rightOperand = _becomeParentOf(expression);
+    _rightOperand = _becomeParentOf(expression as AstNodeImpl);
   }
 
   /**
    * 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`.
    */
   ParameterElement get _propagatedParameterElementForRightOperand {
     if (propagatedElement == null) {
@@ skipping 60 matching lines @@
    * The block representing the body of the function.
    */
   Block _block;
 
   /**
    * Initialize a newly created function body consisting of a block of
    * statements. The [keyword] can be `null` if there is no keyword specified
    * for the block. The [star] can be `null` if there is no star following the
    * keyword (and must be `null` if there is no keyword).
    */
-  BlockFunctionBodyImpl(this.keyword, this.star, Block block) {
+  BlockFunctionBodyImpl(this.keyword, this.star, BlockImpl block) {
     _block = _becomeParentOf(block);
   }
 
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     }
     return _block.beginToken;
   }
 
   @override
   Block get block => _block;
 
   @override
   void set block(Block block) {
-    _block = _becomeParentOf(block);
+    _block = _becomeParentOf(block as AstNodeImpl);
   }
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(keyword)..add(star)..add(_block);
 
   @override
   Token get endToken => _block.endToken;
 
   @override
@@ skipping 151 matching lines @@
    * invalid (e.g. trying to break to a switch case).
    */
   @override
   AstNode target;
 
   /**
    * Initialize a newly created break statement. The [label] can be `null` if
    * there is no label associated with the statement.
    */
   BreakStatementImpl(
-      this.breakKeyword, SimpleIdentifier label, this.semicolon) {
+      this.breakKeyword, SimpleIdentifierImpl label, this.semicolon) {
     _label = _becomeParentOf(label);
   }
 
   @override
   Token get beginToken => breakKeyword;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(breakKeyword)..add(_label)..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   SimpleIdentifier get label => _label;
 
   @override
   void set label(SimpleIdentifier identifier) {
-    _label = _becomeParentOf(identifier);
+    _label = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitBreakStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _label?.accept(visitor);
   }
@@ skipping 24 matching lines @@
 
   /**
    * The cascade sections sharing the common target.
    */
   NodeList<Expression> _cascadeSections;
 
   /**
    * Initialize a newly created cascade expression. The list of
    * [cascadeSections] must contain at least one element.
    */
-  CascadeExpressionImpl(Expression target, List<Expression> cascadeSections) {
+  CascadeExpressionImpl(
+      ExpressionImpl target, List<Expression> cascadeSections) {
     _target = _becomeParentOf(target);
     _cascadeSections = new NodeListImpl<Expression>(this, cascadeSections);
   }
 
   @override
   Token get beginToken => _target.beginToken;
 
   @override
   NodeList<Expression> get cascadeSections => _cascadeSections;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(_target)
     ..addAll(_cascadeSections);
 
   @override
   Token get endToken => _cascadeSections.endToken;
 
   @override
   int get precedence => 2;
 
   @override
   Expression get target => _target;
 
   @override
   void set target(Expression target) {
-    _target = _becomeParentOf(target);
+    _target = _becomeParentOf(target as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitCascadeExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _target?.accept(visitor);
     _cascadeSections.accept(visitor);
@@ skipping 68 matching lines @@
   Block _body;
 
   /**
    * Initialize a newly created catch clause. The [onKeyword] and
    * [exceptionType] can be `null` if the clause will catch all exceptions. The
    * [comma] and [stackTraceParameter] can be `null` if the stack trace
    * parameter is not defined.
    */
   CatchClauseImpl(
       this.onKeyword,
-      TypeName exceptionType,
+      TypeNameImpl exceptionType,
       this.catchKeyword,
       this.leftParenthesis,
-      SimpleIdentifier exceptionParameter,
+      SimpleIdentifierImpl exceptionParameter,
       this.comma,
-      SimpleIdentifier stackTraceParameter,
+      SimpleIdentifierImpl stackTraceParameter,
       this.rightParenthesis,
-      Block body) {
+      BlockImpl body) {
     _exceptionType = _becomeParentOf(exceptionType);
     _exceptionParameter = _becomeParentOf(exceptionParameter);
     _stackTraceParameter = _becomeParentOf(stackTraceParameter);
     _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken {
     if (onKeyword != null) {
       return onKeyword;
     }
     return catchKeyword;
   }
 
   @override
   Block get body => _body;
 
   @override
   void set body(Block block) {
-    _body = _becomeParentOf(block);
+    _body = _becomeParentOf(block as AstNodeImpl);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(onKeyword)
     ..add(_exceptionType)
     ..add(catchKeyword)
     ..add(leftParenthesis)
     ..add(_exceptionParameter)
     ..add(comma)
     ..add(_stackTraceParameter)
     ..add(rightParenthesis)
     ..add(_body);
 
   @override
   Token get endToken => _body.endToken;
 
   @override
   SimpleIdentifier get exceptionParameter => _exceptionParameter;
 
   @override
   void set exceptionParameter(SimpleIdentifier parameter) {
-    _exceptionParameter = _becomeParentOf(parameter);
+    _exceptionParameter = _becomeParentOf(parameter as AstNodeImpl);
   }
 
   @override
   TypeName get exceptionType => _exceptionType;
 
   @override
   void set exceptionType(TypeName exceptionType) {
-    _exceptionType = _becomeParentOf(exceptionType);
+    _exceptionType = _becomeParentOf(exceptionType as AstNodeImpl);
   }
 
   @override
   SimpleIdentifier get stackTraceParameter => _stackTraceParameter;
 
   @override
   void set stackTraceParameter(SimpleIdentifier parameter) {
-    _stackTraceParameter = _becomeParentOf(parameter);
+    _stackTraceParameter = _becomeParentOf(parameter as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitCatchClause(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _exceptionType?.accept(visitor);
     _exceptionParameter?.accept(visitor);
@@ skipping 112 matching lines @@
    * have any type parameters. Any or all of the [extendsClause], [withClause],
    * and [implementsClause] can be `null` if the class does not have the
    * corresponding clause. The list of [members] can be `null` if the class does
    * not have any members.
    */
   ClassDeclarationImpl(
       Comment comment,
       List<Annotation> metadata,
       this.abstractKeyword,
       this.classKeyword,
-      SimpleIdentifier name,
-      TypeParameterList typeParameters,
-      ExtendsClause extendsClause,
-      WithClause withClause,
-      ImplementsClause implementsClause,
+      SimpleIdentifierImpl name,
+      TypeParameterListImpl typeParameters,
+      ExtendsClauseImpl extendsClause,
+      WithClauseImpl withClause,
+      ImplementsClauseImpl implementsClause,
       this.leftBracket,
       List<ClassMember> members,
       this.rightBracket)
       : super(comment, metadata, name) {
     _typeParameters = _becomeParentOf(typeParameters);
     _extendsClause = _becomeParentOf(extendsClause);
     _withClause = _becomeParentOf(withClause);
     _implementsClause = _becomeParentOf(implementsClause);
     _members = new NodeListImpl<ClassMember>(this, members);
   }
@@ skipping 16 matching lines @@
   ClassElement get element => _name?.staticElement as ClassElement;
 
   @override
   Token get endToken => rightBracket;
 
   @override
   ExtendsClause get extendsClause => _extendsClause;
 
   @override
   void set extendsClause(ExtendsClause extendsClause) {
-    _extendsClause = _becomeParentOf(extendsClause);
+    _extendsClause = _becomeParentOf(extendsClause as AstNodeImpl);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata {
     if (abstractKeyword != null) {
       return abstractKeyword;
     }
     return classKeyword;
   }
 
   @override
   ImplementsClause get implementsClause => _implementsClause;
 
   @override
   void set implementsClause(ImplementsClause implementsClause) {
-    _implementsClause = _becomeParentOf(implementsClause);
+    _implementsClause = _becomeParentOf(implementsClause as AstNodeImpl);
   }
 
   @override
   bool get isAbstract => abstractKeyword != null;
 
   @override
   NodeList<ClassMember> get members => _members;
 
   @override
   NativeClause get nativeClause => _nativeClause;
 
   @override
   void set nativeClause(NativeClause nativeClause) {
-    _nativeClause = _becomeParentOf(nativeClause);
+    _nativeClause = _becomeParentOf(nativeClause as AstNodeImpl);
   }
 
   @override
   TypeParameterList get typeParameters => _typeParameters;
 
   @override
   void set typeParameters(TypeParameterList typeParameters) {
-    _typeParameters = _becomeParentOf(typeParameters);
+    _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
   }
 
   @override
   WithClause get withClause => _withClause;
 
   @override
   void set withClause(WithClause withClause) {
-    _withClause = _becomeParentOf(withClause);
+    _withClause = _becomeParentOf(withClause as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitClassDeclaration(this);
 
   @override
   ConstructorDeclaration getConstructor(String name) {
     for (ClassMember classMember in _members) {
       if (classMember is ConstructorDeclaration) {
@@ skipping 115 matching lines @@
 
   /**
    * Initialize a newly created class type alias. Either or both of the
    * [comment] and [metadata] can be `null` if the class type alias does not
    * have the corresponding attribute. The [typeParameters] can be `null` if the
    * class does not have any type parameters. The [abstractKeyword] can be
    * `null` if the class is not abstract. The [implementsClause] can be `null`
    * if the class does not implement any interfaces.
    */
   ClassTypeAliasImpl(
-      Comment comment,
+      CommentImpl comment,
       List<Annotation> metadata,
       Token keyword,
-      SimpleIdentifier name,
-      TypeParameterList typeParameters,
+      SimpleIdentifierImpl name,
+      TypeParameterListImpl typeParameters,
       this.equals,
       this.abstractKeyword,
-      TypeName superclass,
-      WithClause withClause,
-      ImplementsClause implementsClause,
+      TypeNameImpl superclass,
+      WithClauseImpl withClause,
+      ImplementsClauseImpl implementsClause,
       Token semicolon)
       : super(comment, metadata, keyword, name, semicolon) {
     _typeParameters = _becomeParentOf(typeParameters);
     _superclass = _becomeParentOf(superclass);
     _withClause = _becomeParentOf(withClause);
     _implementsClause = _becomeParentOf(implementsClause);
   }
 
   @override
   Iterable get childEntities => super._childEntities
@@ skipping 16 matching lines @@
       return abstractKeyword;
     }
     return typedefKeyword;
   }
 
   @override
   ImplementsClause get implementsClause => _implementsClause;
 
   @override
   void set implementsClause(ImplementsClause implementsClause) {
-    _implementsClause = _becomeParentOf(implementsClause);
+    _implementsClause = _becomeParentOf(implementsClause as AstNodeImpl);
   }
 
   @override
   bool get isAbstract => abstractKeyword != null;
 
   @override
   TypeName get superclass => _superclass;
 
   @override
   void set superclass(TypeName superclass) {
-    _superclass = _becomeParentOf(superclass);
+    _superclass = _becomeParentOf(superclass as AstNodeImpl);
   }
 
   @override
   TypeParameterList get typeParameters => _typeParameters;
 
   @override
   void set typeParameters(TypeParameterList typeParameters) {
-    _typeParameters = _becomeParentOf(typeParameters);
+    _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
   }
 
   @override
   WithClause get withClause => _withClause;
 
   @override
   void set withClause(WithClause withClause) {
-    _withClause = _becomeParentOf(withClause);
+    _withClause = _becomeParentOf(withClause as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitClassTypeAlias(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _name?.accept(visitor);
@@ skipping 149 matching lines @@
 
   /**
    * The identifier being referenced.
    */
   Identifier _identifier;
 
   /**
    * Initialize a newly created reference to a Dart element. The [newKeyword]
    * can be `null` if the reference is not to a constructor.
    */
-  CommentReferenceImpl(this.newKeyword, Identifier identifier) {
+  CommentReferenceImpl(this.newKeyword, IdentifierImpl identifier) {
     _identifier = _becomeParentOf(identifier);
   }
 
   @override
   Token get beginToken => _identifier.beginToken;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(newKeyword)..add(_identifier);
 
   @override
   Token get endToken => _identifier.endToken;
 
   @override
   Identifier get identifier => _identifier;
 
   @override
   void set identifier(Identifier identifier) {
-    _identifier = _becomeParentOf(identifier);
+    _identifier = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitCommentReference(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _identifier?.accept(visitor);
   }
@@ skipping 101 matching lines @@
 
   /**
    * Initialize a newly created compilation unit to have the given directives
    * and declarations. The [scriptTag] can be `null` if there is no script tag
    * in the compilation unit. The list of [directives] can be `null` if there
    * are no directives in the compilation unit. The list of [declarations] can
    * be `null` if there are no declarations in the compilation unit.
    */
   CompilationUnitImpl(
       this.beginToken,
-      ScriptTag scriptTag,
+      ScriptTagImpl scriptTag,
       List<Directive> directives,
       List<CompilationUnitMember> declarations,
       this.endToken) {
     _scriptTag = _becomeParentOf(scriptTag);
     _directives = new NodeListImpl<Directive>(this, directives);
     _declarations = new NodeListImpl<CompilationUnitMember>(this, declarations);
   }
 
   @override
   Iterable get childEntities {
@@ skipping 22 matching lines @@
   }
 
   @override
   int get offset => 0;
 
   @override
   ScriptTag get scriptTag => _scriptTag;
 
   @override
   void set scriptTag(ScriptTag scriptTag) {
-    _scriptTag = _becomeParentOf(scriptTag);
+    _scriptTag = _becomeParentOf(scriptTag as AstNodeImpl);
   }
 
   @override
   List<AstNode> get sortedDirectivesAndDeclarations {
     return <AstNode>[]
       ..addAll(_directives)
       ..addAll(_declarations)
       ..sort(AstNode.LEXICAL_ORDER);
   }
 
@@ skipping 82 matching lines @@
   Token colon;
 
   /**
    * The expression that is executed if the condition evaluates to `false`.
    */
   Expression _elseExpression;
 
   /**
    * Initialize a newly created conditional expression.
    */
-  ConditionalExpressionImpl(Expression condition, this.question,
-      Expression thenExpression, this.colon, Expression elseExpression) {
+  ConditionalExpressionImpl(
+      ExpressionImpl condition,
+      this.question,
+      ExpressionImpl thenExpression,
+      this.colon,
+      ExpressionImpl elseExpression) {
     _condition = _becomeParentOf(condition);
     _thenExpression = _becomeParentOf(thenExpression);
     _elseExpression = _becomeParentOf(elseExpression);
   }
 
   @override
   Token get beginToken => _condition.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(_condition)
     ..add(question)
     ..add(_thenExpression)
     ..add(colon)
     ..add(_elseExpression);
 
   @override
   Expression get condition => _condition;
 
   @override
   void set condition(Expression expression) {
-    _condition = _becomeParentOf(expression);
+    _condition = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   Expression get elseExpression => _elseExpression;
 
   @override
   void set elseExpression(Expression expression) {
-    _elseExpression = _becomeParentOf(expression);
+    _elseExpression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   Token get endToken => _elseExpression.endToken;
 
   @override
   int get precedence => 3;
 
   @override
   Expression get thenExpression => _thenExpression;
 
   @override
   void set thenExpression(Expression expression) {
-    _thenExpression = _becomeParentOf(expression);
+    _thenExpression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitConditionalExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _condition?.accept(visitor);
     _thenExpression?.accept(visitor);
@@ skipping 22 matching lines @@
   @override
   Token equalToken;
   StringLiteral _value;
   @override
   Token rightParenthesis;
   StringLiteral _libraryUri;
 
   ConfigurationImpl(
       this.ifKeyword,
       this.leftParenthesis,
-      DottedName name,
+      DottedNameImpl name,
       this.equalToken,
-      StringLiteral value,
+      StringLiteralImpl value,
       this.rightParenthesis,
-      StringLiteral libraryUri) {
+      StringLiteralImpl libraryUri) {
     _name = _becomeParentOf(name);
     _value = _becomeParentOf(value);
     _libraryUri = _becomeParentOf(libraryUri);
   }
 
   @override
   Token get beginToken => ifKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(ifKeyword)
     ..add(leftParenthesis)
     ..add(_name)
     ..add(equalToken)
     ..add(_value)
     ..add(rightParenthesis)
     ..add(_libraryUri);
 
   @override
   Token get endToken => _libraryUri.endToken;
 
   @override
   StringLiteral get libraryUri => _libraryUri;
 
   @override
   void set libraryUri(StringLiteral libraryUri) {
-    _libraryUri = _becomeParentOf(libraryUri);
+    _libraryUri = _becomeParentOf(libraryUri as AstNodeImpl);
   }
 
   @override
   DottedName get name => _name;
 
   @override
   void set name(DottedName name) {
-    _name = _becomeParentOf(name);
+    _name = _becomeParentOf(name as AstNodeImpl);
   }
 
   @override
   StringLiteral get value => _value;
 
   @override
   void set value(StringLiteral value) {
-    _value = _becomeParentOf(value);
+    _value = _becomeParentOf(value as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitConfiguration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _name?.accept(visitor);
     _value?.accept(visitor);
@@ skipping 111 matching lines @@
    * be `null` if the constructor is not a factory. The [period] and [name] can
    * both be `null` if the constructor is not a named constructor. The
    * [separator] can be `null` if the constructor does not have any initializers
    * and does not redirect to a different constructor. The list of
    * [initializers] can be `null` if the constructor does not have any
    * initializers. The [redirectedConstructor] can be `null` if the constructor
    * does not redirect to a different constructor. The [body] can be `null` if
    * the constructor does not have a body.
    */
   ConstructorDeclarationImpl(
-      Comment comment,
+      CommentImpl comment,
       List<Annotation> metadata,
       this.externalKeyword,
       this.constKeyword,
       this.factoryKeyword,
-      Identifier returnType,
+      IdentifierImpl returnType,
       this.period,
-      SimpleIdentifier name,
-      FormalParameterList parameters,
+      SimpleIdentifierImpl name,
+      FormalParameterListImpl parameters,
       this.separator,
       List<ConstructorInitializer> initializers,
-      ConstructorName redirectedConstructor,
-      FunctionBody body)
+      ConstructorNameImpl redirectedConstructor,
+      FunctionBodyImpl body)
       : super(comment, metadata) {
     _returnType = _becomeParentOf(returnType);
     _name = _becomeParentOf(name);
     _parameters = _becomeParentOf(parameters);
     _initializers =
         new NodeListImpl<ConstructorInitializer>(this, initializers);
     _redirectedConstructor = _becomeParentOf(redirectedConstructor);
     _body = _becomeParentOf(body);
   }
 
   @override
   FunctionBody get body => _body;
 
   @override
   void set body(FunctionBody functionBody) {
-    _body = _becomeParentOf(functionBody);
+    _body = _becomeParentOf(functionBody as AstNodeImpl);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(externalKeyword)
     ..add(constKeyword)
     ..add(factoryKeyword)
     ..add(_returnType)
     ..add(period)
     ..add(_name)
@@ skipping 24 matching lines @@
   }
 
   @override
   NodeList<ConstructorInitializer> get initializers => _initializers;
 
   @override
   SimpleIdentifier get name => _name;
 
   @override
   void set name(SimpleIdentifier identifier) {
-    _name = _becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   FormalParameterList get parameters => _parameters;
 
   @override
   void set parameters(FormalParameterList parameters) {
-    _parameters = _becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters as AstNodeImpl);
   }
 
   @override
   ConstructorName get redirectedConstructor => _redirectedConstructor;
 
   @override
   void set redirectedConstructor(ConstructorName redirectedConstructor) {
-    _redirectedConstructor = _becomeParentOf(redirectedConstructor);
+    _redirectedConstructor =
+        _becomeParentOf(redirectedConstructor as AstNodeImpl);
   }
 
   @override
   Identifier get returnType => _returnType;
 
   @override
   void set returnType(Identifier typeName) {
-    _returnType = _becomeParentOf(typeName);
+    _returnType = _becomeParentOf(typeName as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitConstructorDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _returnType?.accept(visitor);
@@ skipping 41 matching lines @@
    * The expression computing the value to which the field will be initialized.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created field initializer to initialize the field with
    * the given name to the value of the given expression. The [thisKeyword] and
    * [period] can be `null` if the 'this' keyword was not specified.
    */
   ConstructorFieldInitializerImpl(this.thisKeyword, this.period,
-      SimpleIdentifier fieldName, this.equals, Expression expression) {
+      SimpleIdentifierImpl fieldName, this.equals, ExpressionImpl expression) {
     _fieldName = _becomeParentOf(fieldName);
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken {
     if (thisKeyword != null) {
       return thisKeyword;
     }
     return _fieldName.beginToken;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(thisKeyword)
     ..add(period)
     ..add(_fieldName)
     ..add(equals)
     ..add(_expression);
 
   @override
   Token get endToken => _expression.endToken;
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   SimpleIdentifier get fieldName => _fieldName;
 
   @override
   void set fieldName(SimpleIdentifier identifier) {
-    _fieldName = _becomeParentOf(identifier);
+    _fieldName = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitConstructorFieldInitializer(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _fieldName?.accept(visitor);
     _expression?.accept(visitor);
@@ skipping 41 matching lines @@
    * information, or `null` if the AST structure has not been resolved or if
    * this constructor name could not be resolved.
    */
   @override
   ConstructorElement staticElement;
 
   /**
    * Initialize a newly created constructor name. The [period] and [name] can be
    * `null` if the constructor being named is the unnamed constructor.
    */
-  ConstructorNameImpl(TypeName type, this.period, SimpleIdentifier name) {
+  ConstructorNameImpl(
+      TypeNameImpl type, this.period, SimpleIdentifierImpl name) {
     _type = _becomeParentOf(type);
     _name = _becomeParentOf(name);
   }
 
   @override
   Token get beginToken => _type.beginToken;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_type)..add(period)..add(_name);
 
   @override
   Token get endToken {
     if (_name != null) {
       return _name.endToken;
     }
     return _type.endToken;
   }
 
   @override
   SimpleIdentifier get name => _name;
 
   @override
   void set name(SimpleIdentifier name) {
-    _name = _becomeParentOf(name);
+    _name = _becomeParentOf(name as AstNodeImpl);
   }
 
   @override
   TypeName get type => _type;
 
   @override
   void set type(TypeName type) {
-    _type = _becomeParentOf(type);
+    _type = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitConstructorName(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _type?.accept(visitor);
     _name?.accept(visitor);
@@ skipping 32 matching lines @@
    * Note that if the source code has errors, the target may be invalid (e.g.
    * the target may be in an enclosing function).
    */
   AstNode target;
 
   /**
    * Initialize a newly created continue statement. The [label] can be `null` if
    * there is no label associated with the statement.
    */
   ContinueStatementImpl(
-      this.continueKeyword, SimpleIdentifier label, this.semicolon) {
+      this.continueKeyword, SimpleIdentifierImpl label, this.semicolon) {
     _label = _becomeParentOf(label);
   }
 
   @override
   Token get beginToken => continueKeyword;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(continueKeyword)..add(_label)..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   SimpleIdentifier get label => _label;
 
   @override
   void set label(SimpleIdentifier identifier) {
-    _label = _becomeParentOf(identifier);
+    _label = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitContinueStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _label?.accept(visitor);
   }
@@ skipping 39 matching lines @@
    * The name of the variable being declared.
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [keyword] can be `null` if a type name is
    * given. The [type] must be `null` if the keyword is 'var'.
    */
-  DeclaredIdentifierImpl(Comment comment, List<Annotation> metadata,
-      this.keyword, TypeName type, SimpleIdentifier identifier)
+  DeclaredIdentifierImpl(CommentImpl comment, List<Annotation> metadata,
+      this.keyword, TypeNameImpl type, SimpleIdentifierImpl identifier)
       : super(comment, metadata) {
     _type = _becomeParentOf(type);
     _identifier = _becomeParentOf(identifier);
   }
 
   @override
   Iterable get childEntities =>
       super._childEntities..add(keyword)..add(_type)..add(_identifier);
 
   @override
@@ skipping 15 matching lines @@
       return _type.beginToken;
     }
     return _identifier.beginToken;
   }
 
   @override
   SimpleIdentifier get identifier => _identifier;
 
   @override
   void set identifier(SimpleIdentifier identifier) {
-    _identifier = _becomeParentOf(identifier);
+    _identifier = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   bool get isConst => keyword?.keyword == Keyword.CONST;
 
   @override
   bool get isFinal => keyword?.keyword == Keyword.FINAL;
 
   @override
   TypeName get type => _type;
 
   @override
   void set type(TypeName typeName) {
-    _type = _becomeParentOf(typeName);
+    _type = _becomeParentOf(typeName as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitDeclaredIdentifier(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _type?.accept(visitor);
@@ skipping 53 matching lines @@
   /**
    * The expression computing the default value for the parameter, or `null` if
    * there is no default value.
    */
   Expression _defaultValue;
 
   /**
    * Initialize a newly created default formal parameter. The [separator] and
    * [defaultValue] can be `null` if there is no default value.
    */
-  DefaultFormalParameterImpl(NormalFormalParameter parameter, this.kind,
-      this.separator, Expression defaultValue) {
+  DefaultFormalParameterImpl(NormalFormalParameterImpl parameter, this.kind,
+      this.separator, ExpressionImpl defaultValue) {
     _parameter = _becomeParentOf(parameter);
     _defaultValue = _becomeParentOf(defaultValue);
   }
 
   @override
   Token get beginToken => _parameter.beginToken;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_parameter)..add(separator)..add(_defaultValue);
 
   @override
   Expression get defaultValue => _defaultValue;
 
   @override
   void set defaultValue(Expression expression) {
-    _defaultValue = _becomeParentOf(expression);
+    _defaultValue = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   Token get endToken {
     if (_defaultValue != null) {
       return _defaultValue.endToken;
     }
     return _parameter.endToken;
   }
 
   @override
   SimpleIdentifier get identifier => _parameter.identifier;
 
   @override
   bool get isConst => _parameter != null && _parameter.isConst;
 
   @override
   bool get isFinal => _parameter != null && _parameter.isFinal;
 
   @override
   NodeList<Annotation> get metadata => _parameter.metadata;
 
   @override
   NormalFormalParameter get parameter => _parameter;
 
   @override
   void set parameter(NormalFormalParameter formalParameter) {
-    _parameter = _becomeParentOf(formalParameter);
+    _parameter = _becomeParentOf(formalParameter as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitDefaultFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _parameter?.accept(visitor);
     _defaultValue?.accept(visitor);
@@ skipping 80 matching lines @@
    * The semicolon terminating the statement.
    */
   @override
   Token semicolon;
 
   /**
    * Initialize a newly created do loop.
    */
   DoStatementImpl(
       this.doKeyword,
-      Statement body,
+      StatementImpl body,
       this.whileKeyword,
       this.leftParenthesis,
-      Expression condition,
+      ExpressionImpl condition,
       this.rightParenthesis,
       this.semicolon) {
     _body = _becomeParentOf(body);
     _condition = _becomeParentOf(condition);
   }
 
   @override
   Token get beginToken => doKeyword;
 
   @override
   Statement get body => _body;
 
   @override
   void set body(Statement statement) {
-    _body = _becomeParentOf(statement);
+    _body = _becomeParentOf(statement as AstNodeImpl);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(doKeyword)
     ..add(_body)
     ..add(whileKeyword)
     ..add(leftParenthesis)
     ..add(_condition)
     ..add(rightParenthesis)
     ..add(semicolon);
 
   @override
   Expression get condition => _condition;
 
   @override
   void set condition(Expression expression) {
-    _condition = _becomeParentOf(expression);
+    _condition = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   Token get endToken => semicolon;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitDoStatement(this);
 
   @override
@@ skipping 178 matching lines @@
    */
   SimpleIdentifier _name;
 
   /**
    * Initialize a newly created enum constant declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the constant does not have the
    * corresponding attribute. (Technically, enum constants cannot have metadata,
    * but we allow it for consistency.)
    */
   EnumConstantDeclarationImpl(
-      Comment comment, List<Annotation> metadata, SimpleIdentifier name)
+      CommentImpl comment, List<Annotation> metadata, SimpleIdentifierImpl name)
       : super(comment, metadata) {
     _name = _becomeParentOf(name);
   }
 
   @override
   Iterable get childEntities => super._childEntities..add(_name);
 
   @override
   FieldElement get element => _name?.staticElement as FieldElement;
 
   @override
   Token get endToken => _name.endToken;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 
   @override
   SimpleIdentifier get name => _name;
 
   @override
   void set name(SimpleIdentifier name) {
-    _name = _becomeParentOf(name);
+    _name = _becomeParentOf(name as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitEnumConstantDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _name?.accept(visitor);
@@ skipping 178 matching lines @@
    */
   @override
   Token semicolon;
 
   /**
    * Initialize a newly created function body consisting of a block of
    * statements. The [keyword] can be `null` if the function body is not an
    * async function body.
    */
   ExpressionFunctionBodyImpl(this.keyword, this.functionDefinition,
-      Expression expression, this.semicolon) {
+      ExpressionImpl expression, this.semicolon) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
     }
     return functionDefinition;
   }
@@ skipping 11 matching lines @@
       return semicolon;
     }
     return _expression.endToken;
   }
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   bool get isAsynchronous => keyword != null;
 
   @override
   bool get isSynchronous => keyword == null;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
@@ skipping 125 matching lines @@
   /**
    * The semicolon terminating the statement, or `null` if the expression is a
    * function expression and therefore isn't followed by a semicolon.
    */
   @override
   Token semicolon;
 
   /**
    * Initialize a newly created expression statement.
    */
-  ExpressionStatementImpl(Expression expression, this.semicolon) {
+  ExpressionStatementImpl(ExpressionImpl expression, this.semicolon) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_expression)..add(semicolon);
 
   @override
   Token get endToken {
     if (semicolon != null) {
       return semicolon;
     }
     return _expression.endToken;
   }
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   bool get isSynthetic => _expression.isSynthetic && semicolon.isSynthetic;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitExpressionStatement(this);
 
   @override
@@ skipping 16 matching lines @@
   Token extendsKeyword;
 
   /**
    * The name of the class that is being extended.
    */
   TypeName _superclass;
 
   /**
    * Initialize a newly created extends clause.
    */
-  ExtendsClauseImpl(this.extendsKeyword, TypeName superclass) {
+  ExtendsClauseImpl(this.extendsKeyword, TypeNameImpl superclass) {
     _superclass = _becomeParentOf(superclass);
   }
 
   @override
   Token get beginToken => extendsKeyword;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(extendsKeyword)..add(_superclass);
 
   @override
   Token get endToken => _superclass.endToken;
 
   @override
   TypeName get superclass => _superclass;
 
   @override
   void set superclass(TypeName name) {
-    _superclass = _becomeParentOf(name);
+    _superclass = _becomeParentOf(name as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitExtendsClause(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _superclass?.accept(visitor);
   }
@@ skipping 23 matching lines @@
    */
   @override
   Token semicolon;
 
   /**
    * Initialize a newly created field declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [staticKeyword] can be `null` if the field is
    * not a static field.
    */
-  FieldDeclarationImpl(Comment comment, List<Annotation> metadata,
-      this.staticKeyword, VariableDeclarationList fieldList, this.semicolon)
+  FieldDeclarationImpl(CommentImpl comment, List<Annotation> metadata,
+      this.staticKeyword, VariableDeclarationListImpl fieldList, this.semicolon)
       : super(comment, metadata) {
     _fieldList = _becomeParentOf(fieldList);
   }
 
   @override
   Iterable get childEntities =>
       super._childEntities..add(staticKeyword)..add(_fieldList)..add(semicolon);
 
   @override
   Element get element => null;
 
   @override
   Token get endToken => semicolon;
 
   @override
   VariableDeclarationList get fields => _fieldList;
 
   @override
   void set fields(VariableDeclarationList fields) {
-    _fieldList = _becomeParentOf(fields);
+    _fieldList = _becomeParentOf(fields as AstNodeImpl);
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata {
     if (staticKeyword != null) {
       return staticKeyword;
     }
     return _fieldList.beginToken;
   }
 
@@ skipping 60 matching lines @@
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [keyword] can be `null` if there is a type.
    * The [type] must be `null` if the keyword is 'var'. The [thisKeyword] and
    * [period] can be `null` if the keyword 'this' was not provided.  The
    * [parameters] can be `null` if this is not a function-typed field formal
    * parameter.
    */
   FieldFormalParameterImpl(
-      Comment comment,
+      CommentImpl comment,
       List<Annotation> metadata,
       this.keyword,
-      TypeName type,
+      TypeNameImpl type,
       this.thisKeyword,
       this.period,
-      SimpleIdentifier identifier,
-      TypeParameterList typeParameters,
-      FormalParameterList parameters)
+      SimpleIdentifierImpl identifier,
+      TypeParameterListImpl typeParameters,
+      FormalParameterListImpl parameters)
       : super(comment, metadata, identifier) {
     _type = _becomeParentOf(type);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Token get beginToken {
     if (keyword != null) {
       return keyword;
@@ skipping 24 matching lines @@
   bool get isConst => keyword?.keyword == Keyword.CONST;
 
   @override
   bool get isFinal => keyword?.keyword == Keyword.FINAL;
 
   @override
   FormalParameterList get parameters => _parameters;
 
   @override
   void set parameters(FormalParameterList parameters) {
-    _parameters = _becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters as AstNodeImpl);
   }
 
   @override
   TypeName get type => _type;
 
   @override
   void set type(TypeName typeName) {
-    _type = _becomeParentOf(typeName);
+    _type = _becomeParentOf(typeName as AstNodeImpl);
   }
 
   @override
   TypeParameterList get typeParameters => _typeParameters;
 
   @override
   void set typeParameters(TypeParameterList typeParameters) {
-    _typeParameters = _becomeParentOf(typeParameters);
+    _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitFieldFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _type?.accept(visitor);
@@ skipping 65 matching lines @@
 
   /**
    * Initialize a newly created for-each statement whose loop control variable
    * is declared internally (in the for-loop part). The [awaitKeyword] can be
    * `null` if this is not an asynchronous for loop.
    */
   ForEachStatementImpl.withDeclaration(
       this.awaitKeyword,
       this.forKeyword,
       this.leftParenthesis,
-      DeclaredIdentifier loopVariable,
+      DeclaredIdentifierImpl loopVariable,
       this.inKeyword,
-      Expression iterator,
+      ExpressionImpl iterator,
       this.rightParenthesis,
-      Statement body) {
+      StatementImpl body) {
     _loopVariable = _becomeParentOf(loopVariable);
     _iterable = _becomeParentOf(iterator);
     _body = _becomeParentOf(body);
   }
 
   /**
    * Initialize a newly created for-each statement whose loop control variable
    * is declared outside the for loop. The [awaitKeyword] can be `null` if this
    * is not an asynchronous for loop.
    */
   ForEachStatementImpl.withReference(
       this.awaitKeyword,
       this.forKeyword,
       this.leftParenthesis,
-      SimpleIdentifier identifier,
+      SimpleIdentifierImpl identifier,
       this.inKeyword,
-      Expression iterator,
+      ExpressionImpl iterator,
       this.rightParenthesis,
-      Statement body) {
+      StatementImpl body) {
     _identifier = _becomeParentOf(identifier);
     _iterable = _becomeParentOf(iterator);
     _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken => forKeyword;
 
   @override
   Statement get body => _body;
 
   @override
   void set body(Statement statement) {
-    _body = _becomeParentOf(statement);
+    _body = _becomeParentOf(statement as AstNodeImpl);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(awaitKeyword)
     ..add(forKeyword)
     ..add(leftParenthesis)
     ..add(_loopVariable)
     ..add(_identifier)
     ..add(inKeyword)
     ..add(_iterable)
     ..add(rightParenthesis)
     ..add(_body);
 
   @override
   Token get endToken => _body.endToken;
 
   @override
   SimpleIdentifier get identifier => _identifier;
 
   @override
   void set identifier(SimpleIdentifier identifier) {
-    _identifier = _becomeParentOf(identifier);
+    _identifier = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   Expression get iterable => _iterable;
 
   @override
   void set iterable(Expression expression) {
-    _iterable = _becomeParentOf(expression);
+    _iterable = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   DeclaredIdentifier get loopVariable => _loopVariable;
 
   @override
   void set loopVariable(DeclaredIdentifier variable) {
-    _loopVariable = _becomeParentOf(variable);
+    _loopVariable = _becomeParentOf(variable as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitForEachStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _loopVariable?.accept(visitor);
     _identifier?.accept(visitor);
@@ skipping 216 matching lines @@
 
   /**
    * Initialize a newly created for statement. Either the [variableList] or the
    * [initialization] must be `null`. Either the [condition] and the list of
    * [updaters] can be `null` if the loop does not have the corresponding
    * attribute.
    */
   ForStatementImpl(
       this.forKeyword,
       this.leftParenthesis,
-      VariableDeclarationList variableList,
-      Expression initialization,
+      VariableDeclarationListImpl variableList,
+      ExpressionImpl initialization,
       this.leftSeparator,
-      Expression condition,
+      ExpressionImpl condition,
       this.rightSeparator,
       List<Expression> updaters,
       this.rightParenthesis,
-      Statement body) {
+      StatementImpl body) {
     _variableList = _becomeParentOf(variableList);
     _initialization = _becomeParentOf(initialization);
     _condition = _becomeParentOf(condition);
     _updaters = new NodeListImpl<Expression>(this, updaters);
     _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken => forKeyword;
 
   @override
   Statement get body => _body;
 
   @override
   void set body(Statement statement) {
-    _body = _becomeParentOf(statement);
+    _body = _becomeParentOf(statement as AstNodeImpl);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(forKeyword)
     ..add(leftParenthesis)
     ..add(_variableList)
     ..add(_initialization)
     ..add(leftSeparator)
     ..add(_condition)
     ..add(rightSeparator)
     ..addAll(_updaters)
     ..add(rightParenthesis)
     ..add(_body);
 
   @override
   Expression get condition => _condition;
 
   @override
   void set condition(Expression expression) {
-    _condition = _becomeParentOf(expression);
+    _condition = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   Token get endToken => _body.endToken;
 
   @override
   Expression get initialization => _initialization;
 
   @override
   void set initialization(Expression initialization) {
-    _initialization = _becomeParentOf(initialization);
+    _initialization = _becomeParentOf(initialization as AstNodeImpl);
   }
 
   @override
   NodeList<Expression> get updaters => _updaters;
 
   @override
   VariableDeclarationList get variables => _variableList;
 
   @override
   void set variables(VariableDeclarationList variableList) {
-    _variableList = _becomeParentOf(variableList);
+    _variableList = _becomeParentOf(variableList as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitForStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _variableList?.accept(visitor);
     _initialization?.accept(visitor);
@@ skipping 106 matching lines @@
 
   /**
    * Initialize a newly created function declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [externalKeyword] can be `null` if the
    * function is not an external function. The [returnType] can be `null` if no
    * return type was specified. The [propertyKeyword] can be `null` if the
    * function is neither a getter or a setter.
    */
   FunctionDeclarationImpl(
-      Comment comment,
+      CommentImpl comment,
       List<Annotation> metadata,
       this.externalKeyword,
-      TypeName returnType,
+      TypeNameImpl returnType,
       this.propertyKeyword,
-      SimpleIdentifier name,
-      FunctionExpression functionExpression)
+      SimpleIdentifierImpl name,
+      FunctionExpressionImpl functionExpression)
       : super(comment, metadata, name) {
     _returnType = _becomeParentOf(returnType);
     _functionExpression = _becomeParentOf(functionExpression);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(externalKeyword)
     ..add(_returnType)
     ..add(propertyKeyword)
@@ skipping 18 matching lines @@
       return _name.beginToken;
     }
     return _functionExpression.beginToken;
   }
 
   @override
   FunctionExpression get functionExpression => _functionExpression;
 
   @override
   void set functionExpression(FunctionExpression functionExpression) {
-    _functionExpression = _becomeParentOf(functionExpression);
+    _functionExpression = _becomeParentOf(functionExpression as AstNodeImpl);
   }
 
   @override
   bool get isGetter => propertyKeyword?.keyword == Keyword.GET;
 
   @override
   bool get isSetter => propertyKeyword?.keyword == Keyword.SET;
 
   @override
   TypeName get returnType => _returnType;
 
   @override
   void set returnType(TypeName returnType) {
-    _returnType = _becomeParentOf(returnType);
+    _returnType = _becomeParentOf(returnType as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitFunctionDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _returnType?.accept(visitor);
     _name?.accept(visitor);
     _functionExpression?.accept(visitor);
   }
 }
 
 /**
  * A [FunctionDeclaration] used as a statement.
  */
 class FunctionDeclarationStatementImpl extends StatementImpl
     implements FunctionDeclarationStatement {
   /**
    * The function declaration being wrapped.
    */
   FunctionDeclaration _functionDeclaration;
 
   /**
    * Initialize a newly created function declaration statement.
    */
   FunctionDeclarationStatementImpl(FunctionDeclaration functionDeclaration) {
-    _functionDeclaration = _becomeParentOf(functionDeclaration);
+    _functionDeclaration = _becomeParentOf(functionDeclaration as AstNodeImpl);
   }
 
   @override
   Token get beginToken => _functionDeclaration.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()..add(_functionDeclaration);
 
   @override
   Token get endToken => _functionDeclaration.endToken;
 
   @override
   FunctionDeclaration get functionDeclaration => _functionDeclaration;
 
   @override
   void set functionDeclaration(FunctionDeclaration functionDeclaration) {
-    _functionDeclaration = _becomeParentOf(functionDeclaration);
+    _functionDeclaration = _becomeParentOf(functionDeclaration as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitFunctionDeclarationStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _functionDeclaration?.accept(visitor);
   }
@@ skipping 26 matching lines @@
   /**
    * The element associated with the function, or `null` if the AST structure
    * has not been resolved.
    */
   @override
   ExecutableElement element;
 
   /**
    * Initialize a newly created function declaration.
    */
-  FunctionExpressionImpl(TypeParameterList typeParameters,
-      FormalParameterList parameters, FunctionBody body) {
+  FunctionExpressionImpl(TypeParameterListImpl typeParameters,
+      FormalParameterListImpl parameters, FunctionBodyImpl body) {
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
     _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken {
     if (_typeParameters != null) {
       return _typeParameters.beginToken;
     } else 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");
   }
 
   @override
   FunctionBody get body => _body;
 
   @override
   void set body(FunctionBody functionBody) {
-    _body = _becomeParentOf(functionBody);
+    _body = _becomeParentOf(functionBody as AstNodeImpl);
   }
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_parameters)..add(_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");
   }
 
   @override
   FormalParameterList get parameters => _parameters;
 
   @override
   void set parameters(FormalParameterList parameters) {
-    _parameters = _becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters as AstNodeImpl);
   }
 
   @override
   int get precedence => 16;
 
   @override
   TypeParameterList get typeParameters => _typeParameters;
 
   @override
   void set typeParameters(TypeParameterList typeParameters) {
-    _typeParameters = _becomeParentOf(typeParameters);
+    _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitFunctionExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _typeParameters?.accept(visitor);
     _parameters?.accept(visitor);
@@ skipping 29 matching lines @@
    * 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.
    */
   @override
   ExecutableElement propagatedElement;
 
   /**
    * Initialize a newly created function expression invocation.
    */
-  FunctionExpressionInvocationImpl(Expression function,
-      TypeArgumentList typeArguments, ArgumentList argumentList)
+  FunctionExpressionInvocationImpl(ExpressionImpl function,
+      TypeArgumentListImpl typeArguments, ArgumentListImpl argumentList)
       : super(typeArguments, argumentList) {
     _function = _becomeParentOf(function);
   }
 
   @override
   Token get beginToken => _function.beginToken;
 
   @override
   ExecutableElement get bestElement {
     ExecutableElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_function)..add(_argumentList);
 
   @override
   Token get endToken => _argumentList.endToken;
 
   @override
   Expression get function => _function;
 
   @override
   void set function(Expression expression) {
-    _function = _becomeParentOf(expression);
+    _function = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => 15;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitFunctionExpressionInvocation(this);
 
   @override
@@ skipping 32 matching lines @@
   FormalParameterList _parameters;
 
   /**
    * Initialize a newly created function type alias. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified. The [typeParameters] can be `null` if the function has no
    * type parameters.
    */
   FunctionTypeAliasImpl(
-      Comment comment,
+      CommentImpl comment,
       List<Annotation> metadata,
       Token keyword,
-      TypeName returnType,
-      SimpleIdentifier name,
-      TypeParameterList typeParameters,
-      FormalParameterList parameters,
+      TypeNameImpl returnType,
+      SimpleIdentifierImpl name,
+      TypeParameterListImpl typeParameters,
+      FormalParameterListImpl parameters,
       Token semicolon)
       : super(comment, metadata, keyword, name, semicolon) {
     _returnType = _becomeParentOf(returnType);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(typedefKeyword)
     ..add(_returnType)
     ..add(_name)
     ..add(_typeParameters)
     ..add(_parameters)
     ..add(semicolon);
 
   @override
   FunctionTypeAliasElement get element =>
       _name?.staticElement as FunctionTypeAliasElement;
 
   @override
   FormalParameterList get parameters => _parameters;
 
   @override
   void set parameters(FormalParameterList parameters) {
-    _parameters = _becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters as AstNodeImpl);
   }
 
   @override
   TypeName get returnType => _returnType;
 
   @override
   void set returnType(TypeName typeName) {
-    _returnType = _becomeParentOf(typeName);
+    _returnType = _becomeParentOf(typeName as AstNodeImpl);
   }
 
   @override
   TypeParameterList get typeParameters => _typeParameters;
 
   @override
   void set typeParameters(TypeParameterList typeParameters) {
-    _typeParameters = _becomeParentOf(typeParameters);
+    _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitFunctionTypeAlias(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _returnType?.accept(visitor);
@@ skipping 28 matching lines @@
    */
   FormalParameterList _parameters;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified.
    */
   FunctionTypedFormalParameterImpl(
-      Comment comment,
+      CommentImpl comment,
       List<Annotation> metadata,
-      TypeName returnType,
-      SimpleIdentifier identifier,
-      TypeParameterList typeParameters,
-      FormalParameterList parameters)
+      TypeNameImpl returnType,
+      SimpleIdentifierImpl identifier,
+      TypeParameterListImpl typeParameters,
+      FormalParameterListImpl parameters)
       : super(comment, metadata, identifier) {
     _returnType = _becomeParentOf(returnType);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
   }
 
   @override
   Token get beginToken {
     if (_returnType != null) {
       return _returnType.beginToken;
@@ skipping 12 matching lines @@
   bool get isConst => false;
 
   @override
   bool get isFinal => false;
 
   @override
   FormalParameterList get parameters => _parameters;
 
   @override
   void set parameters(FormalParameterList parameters) {
-    _parameters = _becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters as AstNodeImpl);
   }
 
   @override
   TypeName get returnType => _returnType;
 
   @override
   void set returnType(TypeName type) {
-    _returnType = _becomeParentOf(type);
+    _returnType = _becomeParentOf(type as AstNodeImpl);
   }
 
   @override
   TypeParameterList get typeParameters => _typeParameters;
 
   @override
   void set typeParameters(TypeParameterList typeParameters) {
-    _typeParameters = _becomeParentOf(typeParameters);
+    _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitFunctionTypedFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _returnType?.accept(visitor);
@@ skipping 114 matching lines @@
    */
   Statement _elseStatement;
 
   /**
    * Initialize a newly created if statement. The [elseKeyword] and
    * [elseStatement] can be `null` if there is no else clause.
    */
   IfStatementImpl(
       this.ifKeyword,
       this.leftParenthesis,
-      Expression condition,
+      ExpressionImpl condition,
       this.rightParenthesis,
-      Statement thenStatement,
+      StatementImpl thenStatement,
       this.elseKeyword,
-      Statement elseStatement) {
+      StatementImpl elseStatement) {
     _condition = _becomeParentOf(condition);
     _thenStatement = _becomeParentOf(thenStatement);
     _elseStatement = _becomeParentOf(elseStatement);
   }
 
   @override
   Token get beginToken => ifKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(ifKeyword)
     ..add(leftParenthesis)
     ..add(_condition)
     ..add(rightParenthesis)
     ..add(_thenStatement)
     ..add(elseKeyword)
     ..add(_elseStatement);
 
   @override
   Expression get condition => _condition;
 
   @override
   void set condition(Expression expression) {
-    _condition = _becomeParentOf(expression);
+    _condition = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   Statement get elseStatement => _elseStatement;
 
   @override
   void set elseStatement(Statement statement) {
-    _elseStatement = _becomeParentOf(statement);
+    _elseStatement = _becomeParentOf(statement as AstNodeImpl);
   }
 
   @override
   Token get endToken {
     if (_elseStatement != null) {
       return _elseStatement.endToken;
     }
     return _thenStatement.endToken;
   }
 
   @override
   Statement get thenStatement => _thenStatement;
 
   @override
   void set thenStatement(Statement statement) {
-    _thenStatement = _becomeParentOf(statement);
+    _thenStatement = _becomeParentOf(statement as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitIfStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _condition?.accept(visitor);
     _thenStatement?.accept(visitor);
@@ skipping 81 matching lines @@
 
   /**
    * Initialize a newly created import directive. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [deferredKeyword] can be `null` if the import
    * is not deferred. The [asKeyword] and [prefix] can be `null` if the import
    * does not specify a prefix. The list of [combinators] can be `null` if there
    * are no combinators.
    */
   ImportDirectiveImpl(
-      Comment comment,
+      CommentImpl comment,
       List<Annotation> metadata,
       Token keyword,
-      StringLiteral libraryUri,
+      StringLiteralImpl libraryUri,
       List<Configuration> configurations,
       this.deferredKeyword,
       this.asKeyword,
-      SimpleIdentifier prefix,
+      SimpleIdentifierImpl prefix,
       List<Combinator> combinators,
       Token semicolon)
       : super(comment, metadata, keyword, libraryUri, configurations,
             combinators, semicolon) {
     _prefix = _becomeParentOf(prefix);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(_uri)
     ..add(deferredKeyword)
     ..add(asKeyword)
     ..add(_prefix)
     ..addAll(combinators)
     ..add(semicolon);
 
   @override
   ImportElement get element => super.element as ImportElement;
 
   @override
   SimpleIdentifier get prefix => _prefix;
 
   @override
   void set prefix(SimpleIdentifier identifier) {
-    _prefix = _becomeParentOf(identifier);
+    _prefix = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   LibraryElement get uriElement {
     ImportElement element = this.element;
     if (element == null) {
       return null;
     }
     return element.importedLibrary;
   }
@@ skipping 69 matching lines @@
    * [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.
    */
   IndexExpressionImpl.forCascade(
-      this.period, this.leftBracket, Expression index, this.rightBracket) {
+      this.period, this.leftBracket, ExpressionImpl index, this.rightBracket) {
     _index = _becomeParentOf(index);
   }
 
   /**
    * Initialize a newly created index expression.
    */
-  IndexExpressionImpl.forTarget(Expression target, this.leftBracket,
-      Expression index, this.rightBracket) {
+  IndexExpressionImpl.forTarget(ExpressionImpl target, this.leftBracket,
+      ExpressionImpl index, this.rightBracket) {
     _target = _becomeParentOf(target);
     _index = _becomeParentOf(index);
   }
 
   @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return period;
@@ skipping 17 matching lines @@
     ..add(rightBracket);
 
   @override
   Token get endToken => rightBracket;
 
   @override
   Expression get index => _index;
 
   @override
   void set index(Expression expression) {
-    _index = _becomeParentOf(expression);
+    _index = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   bool get isAssignable => true;
 
   @override
   bool get isCascaded => period != null;
 
   @override
   int get precedence => 15;
@@ skipping 11 matching lines @@
       return (ancestor as CascadeExpression).target;
     }
     return _target;
   }
 
   @override
   Expression get target => _target;
 
   @override
   void set target(Expression expression) {
-    _target = _becomeParentOf(expression);
+    _target = _becomeParentOf(expression as AstNodeImpl);
   }
 
   /**
    * 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`.
    */
   ParameterElement get _propagatedParameterElementForIndex {
     if (propagatedElement == null) {
@@ skipping 91 matching lines @@
    * The element associated with the constructor based on static type
    * information, or `null` if the AST structure has not been resolved or if the
    * constructor could not be resolved.
    */
   @override
   ConstructorElement staticElement;
 
   /**
    * Initialize a newly created instance creation expression.
    */
-  InstanceCreationExpressionImpl(this.keyword, ConstructorName constructorName,
-      ArgumentList argumentList) {
+  InstanceCreationExpressionImpl(this.keyword,
+      ConstructorNameImpl constructorName, ArgumentListImpl argumentList) {
     _constructorName = _becomeParentOf(constructorName);
     _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
   ArgumentList get argumentList => _argumentList;
 
   @override
   void set argumentList(ArgumentList argumentList) {
-    _argumentList = _becomeParentOf(argumentList);
+    _argumentList = _becomeParentOf(argumentList as AstNodeImpl);
   }
 
   @override
   Token get beginToken => keyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(keyword)
     ..add(_constructorName)
     ..add(_argumentList);
 
   @override
   ConstructorName get constructorName => _constructorName;
 
   @override
   void set constructorName(ConstructorName name) {
-    _constructorName = _becomeParentOf(name);
+    _constructorName = _becomeParentOf(name as AstNodeImpl);
   }
 
   @override
   Token get endToken => _argumentList.endToken;
 
   @override
   bool get isConst => keyword?.keyword == Keyword.CONST;
 
   @override
   int get precedence => 16;
@@ skipping 96 matching lines @@
    * The right curly bracket, or `null` if the expression is an identifier
    * without brackets.
    */
   @override
   Token rightBracket;
 
   /**
    * Initialize a newly created interpolation expression.
    */
   InterpolationExpressionImpl(
-      this.leftBracket, Expression expression, this.rightBracket) {
+      this.leftBracket, ExpressionImpl expression, this.rightBracket) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(leftBracket)
     ..add(_expression)
     ..add(rightBracket);
 
   @override
   Token get endToken {
     if (rightBracket != null) {
       return rightBracket;
     }
     return _expression.endToken;
   }
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitInterpolationExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _expression?.accept(visitor);
   }
@@ skipping 75 matching lines @@
   @override
   DartType propagatedInvokeType;
 
   @override
   DartType staticInvokeType;
 
   /**
    * Initialize a newly created invocation.
    */
   InvocationExpressionImpl(
-      TypeArgumentList typeArguments, ArgumentList argumentList) {
+      TypeArgumentListImpl typeArguments, ArgumentListImpl argumentList) {
     _typeArguments = _becomeParentOf(typeArguments);
     _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
   ArgumentList get argumentList => _argumentList;
 
   void set argumentList(ArgumentList argumentList) {
-    _argumentList = _becomeParentOf(argumentList);
+    _argumentList = _becomeParentOf(argumentList as AstNodeImpl);
   }
 
   @override
   TypeArgumentList get typeArguments => _typeArguments;
 
   void set typeArguments(TypeArgumentList typeArguments) {
-    _typeArguments = _becomeParentOf(typeArguments);
+    _typeArguments = _becomeParentOf(typeArguments as AstNodeImpl);
   }
 }
 
 /**
  * An is expression.
  *
  *    isExpression ::=
  *        [Expression] 'is' '!'? [TypeName]
  */
 class IsExpressionImpl extends ExpressionImpl implements IsExpression {
@@ skipping 16 matching lines @@
 
   /**
    * The name of the type being tested for.
    */
   TypeName _type;
 
   /**
    * Initialize a newly created is expression. The [notOperator] can be `null`
    * if the sense of the test is not negated.
    */
-  IsExpressionImpl(
-      Expression expression, this.isOperator, this.notOperator, TypeName type) {
+  IsExpressionImpl(ExpressionImpl expression, this.isOperator, this.notOperator,
+      TypeNameImpl type) {
     _expression = _becomeParentOf(expression);
     _type = _becomeParentOf(type);
   }
 
   @override
   Token get beginToken => _expression.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(_expression)
     ..add(isOperator)
     ..add(notOperator)
     ..add(_type);
 
   @override
   Token get endToken => _type.endToken;
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => 7;
 
   @override
   TypeName get type => _type;
 
   @override
   void set type(TypeName name) {
-    _type = _becomeParentOf(name);
+    _type = _becomeParentOf(name as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitIsExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _expression?.accept(visitor);
     _type?.accept(visitor);
@@ skipping 13 matching lines @@
   NodeList<Label> _labels;
 
   /**
    * The statement with which the labels are being associated.
    */
   Statement _statement;
 
   /**
    * Initialize a newly created labeled statement.
    */
-  LabeledStatementImpl(List<Label> labels, Statement statement) {
+  LabeledStatementImpl(List<Label> labels, StatementImpl statement) {
     _labels = new NodeListImpl<Label>(this, labels);
     _statement = _becomeParentOf(statement);
   }
 
   @override
   Token get beginToken {
     if (!_labels.isEmpty) {
       return _labels.beginToken;
     }
     return _statement.beginToken;
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..addAll(_labels)
     ..add(_statement);
 
   @override
   Token get endToken => _statement.endToken;
 
   @override
   NodeList<Label> get labels => _labels;
 
   @override
   Statement get statement => _statement;
 
   @override
   void set statement(Statement statement) {
-    _statement = _becomeParentOf(statement);
+    _statement = _becomeParentOf(statement as AstNodeImpl);
   }
 
   @override
   Statement get unlabeled => _statement.unlabeled;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitLabeledStatement(this);
 
   @override
@@ skipping 17 matching lines @@
 
   /**
    * The colon that separates the label from the statement.
    */
   @override
   Token colon;
 
   /**
    * Initialize a newly created label.
    */
-  LabelImpl(SimpleIdentifier label, this.colon) {
+  LabelImpl(SimpleIdentifierImpl label, this.colon) {
     _label = _becomeParentOf(label);
   }
 
   @override
   Token get beginToken => _label.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()..add(_label)..add(colon);
 
   @override
   Token get endToken => colon;
 
   @override
   SimpleIdentifier get label => _label;
 
   @override
   void set label(SimpleIdentifier label) {
-    _label = _becomeParentOf(label);
+    _label = _becomeParentOf(label as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitLabel(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _label?.accept(visitor);
   }
@@ skipping 21 matching lines @@
    * The semicolon terminating the directive.
    */
   @override
   Token semicolon;
 
   /**
    * Initialize a newly created library directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
-  LibraryDirectiveImpl(Comment comment, List<Annotation> metadata,
-      this.libraryKeyword, LibraryIdentifier name, this.semicolon)
+  LibraryDirectiveImpl(CommentImpl comment, List<Annotation> metadata,
+      this.libraryKeyword, LibraryIdentifierImpl name, this.semicolon)
       : super(comment, metadata) {
     _name = _becomeParentOf(name);
   }
 
   @override
   Iterable get childEntities =>
       super._childEntities..add(libraryKeyword)..add(_name)..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => libraryKeyword;
 
   @override
   Token get keyword => libraryKeyword;
 
   @override
   LibraryIdentifier get name => _name;
 
   @override
   void set name(LibraryIdentifier name) {
-    _name = _becomeParentOf(name);
+    _name = _becomeParentOf(name as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitLibraryDirective(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _name?.accept(visitor);
@@ skipping 198 matching lines @@
   Token separator;
 
   /**
    * The expression computing the value that will be associated with the key.
    */
   Expression _value;
 
   /**
    * Initialize a newly created map literal entry.
    */
-  MapLiteralEntryImpl(Expression key, this.separator, Expression value) {
+  MapLiteralEntryImpl(
+      ExpressionImpl key, this.separator, ExpressionImpl value) {
     _key = _becomeParentOf(key);
     _value = _becomeParentOf(value);
   }
 
   @override
   Token get beginToken => _key.beginToken;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_key)..add(separator)..add(_value);
 
   @override
   Token get endToken => _value.endToken;
 
   @override
   Expression get key => _key;
 
   @override
   void set key(Expression string) {
-    _key = _becomeParentOf(string);
+    _key = _becomeParentOf(string as AstNodeImpl);
   }
 
   @override
   Expression get value => _value;
 
   @override
   void set value(Expression expression) {
-    _value = _becomeParentOf(expression);
+    _value = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitMapLiteralEntry(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _key?.accept(visitor);
     _value?.accept(visitor);
@@ skipping 148 matching lines @@
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [externalKeyword] can be `null` if the method
    * is not external. The [modifierKeyword] can be `null` if the method is
    * neither abstract nor static. The [returnType] can be `null` if no return
    * type was specified. The [propertyKeyword] can be `null` if the method is
    * neither a getter or a setter. The [operatorKeyword] can be `null` if the
    * method does not implement an operator. The [parameters] must be `null` if
    * this method declares a getter.
    */
   MethodDeclarationImpl(
-      Comment comment,
+      CommentImpl comment,
       List<Annotation> metadata,
       this.externalKeyword,
       this.modifierKeyword,
-      TypeName returnType,
+      TypeNameImpl returnType,
       this.propertyKeyword,
       this.operatorKeyword,
-      SimpleIdentifier name,
-      TypeParameterList typeParameters,
-      FormalParameterList parameters,
-      FunctionBody body)
+      SimpleIdentifierImpl name,
+      TypeParameterListImpl typeParameters,
+      FormalParameterListImpl parameters,
+      FunctionBodyImpl body)
       : super(comment, metadata) {
     _returnType = _becomeParentOf(returnType);
     _name = _becomeParentOf(name);
     _typeParameters = _becomeParentOf(typeParameters);
     _parameters = _becomeParentOf(parameters);
     _body = _becomeParentOf(body);
   }
 
   @override
   FunctionBody get body => _body;
 
   @override
   void set body(FunctionBody functionBody) {
-    _body = _becomeParentOf(functionBody);
+    _body = _becomeParentOf(functionBody as AstNodeImpl);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(externalKeyword)
     ..add(modifierKeyword)
     ..add(_returnType)
     ..add(propertyKeyword)
     ..add(operatorKeyword)
     ..add(_name)
@@ skipping 46 matching lines @@
   bool get isSetter => propertyKeyword?.keyword == Keyword.SET;
 
   @override
   bool get isStatic => modifierKeyword?.keyword == Keyword.STATIC;
 
   @override
   SimpleIdentifier get name => _name;
 
   @override
   void set name(SimpleIdentifier identifier) {
-    _name = _becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   FormalParameterList get parameters => _parameters;
 
   @override
   void set parameters(FormalParameterList parameters) {
-    _parameters = _becomeParentOf(parameters);
+    _parameters = _becomeParentOf(parameters as AstNodeImpl);
   }
 
   @override
   TypeName get returnType => _returnType;
 
   @override
   void set returnType(TypeName typeName) {
-    _returnType = _becomeParentOf(typeName);
+    _returnType = _becomeParentOf(typeName as AstNodeImpl);
   }
 
   @override
   TypeParameterList get typeParameters => _typeParameters;
 
   @override
   void set typeParameters(TypeParameterList typeParameters) {
-    _typeParameters = _becomeParentOf(typeParameters);
+    _typeParameters = _becomeParentOf(typeParameters as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitMethodDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _returnType?.accept(visitor);
@@ skipping 33 matching lines @@
   /**
    * The name of the method being invoked.
    */
   SimpleIdentifier _methodName;
 
   /**
    * Initialize a newly created method invocation. The [target] and [operator]
    * can be `null` if there is no target.
    */
   MethodInvocationImpl(
-      Expression target,
+      ExpressionImpl target,
       this.operator,
-      SimpleIdentifier methodName,
-      TypeArgumentList typeArguments,
-      ArgumentList argumentList)
+      SimpleIdentifierImpl methodName,
+      TypeArgumentListImpl typeArguments,
+      ArgumentListImpl argumentList)
       : super(typeArguments, argumentList) {
     _target = _becomeParentOf(target);
     _methodName = _becomeParentOf(methodName);
   }
 
   @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     } else if (operator != null) {
@@ skipping 17 matching lines @@
 
   @override
   bool get isCascaded =>
       operator != null && operator.type == TokenType.PERIOD_PERIOD;
 
   @override
   SimpleIdentifier get methodName => _methodName;
 
   @override
   void set methodName(SimpleIdentifier identifier) {
-    _methodName = _becomeParentOf(identifier);
+    _methodName = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   int get precedence => 15;
 
   @override
   Expression get realTarget {
     if (isCascaded) {
       AstNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return (ancestor as CascadeExpression).target;
     }
     return _target;
   }
 
   @override
   Expression get target => _target;
 
   @override
   void set target(Expression expression) {
-    _target = _becomeParentOf(expression);
+    _target = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitMethodInvocation(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _target?.accept(visitor);
     _methodName?.accept(visitor);
@@ skipping 11 matching lines @@
    * The name of the member being declared.
    */
   SimpleIdentifier _name;
 
   /**
    * Initialize a newly created compilation unit member with the given [name].
    * Either or both of the [comment] and [metadata] can be `null` if the member
    * does not have the corresponding attribute.
    */
   NamedCompilationUnitMemberImpl(
-      Comment comment, List<Annotation> metadata, SimpleIdentifier name)
+      CommentImpl comment, List<Annotation> metadata, SimpleIdentifierImpl name)
       : super(comment, metadata) {
     _name = _becomeParentOf(name);
   }
 
   @override
   SimpleIdentifier get name => _name;
 
   @override
   void set name(SimpleIdentifier identifier) {
-    _name = _becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier as AstNodeImpl);
   }
 }
 
 /**
  * An expression that has a name associated with it. They are used in method
  * invocations when there are named parameters.
  *
  *    namedExpression ::=
  *        [Label] [Expression]
  */
 class NamedExpressionImpl extends ExpressionImpl implements NamedExpression {
   /**
    * The name associated with the expression.
    */
   Label _name;
 
   /**
    * The expression with which the name is associated.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created named expression..
    */
-  NamedExpressionImpl(Label name, Expression expression) {
+  NamedExpressionImpl(LabelImpl name, ExpressionImpl expression) {
     _name = _becomeParentOf(name);
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => _name.beginToken;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_name)..add(_expression);
 
   @override
   ParameterElement get element {
     Element element = _name.label.staticElement;
     if (element is ParameterElement) {
       return element;
     }
     return null;
   }
 
   @override
   Token get endToken => _expression.endToken;
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   Label get name => _name;
 
   @override
   void set name(Label identifier) {
-    _name = _becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   int get precedence => 0;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitNamedExpression(this);
 
   @override
@@ skipping 84 matching lines @@
   Token nativeKeyword;
 
   /**
    * The name of the native object that implements the class.
    */
   StringLiteral _name;
 
   /**
    * Initialize a newly created native clause.
    */
-  NativeClauseImpl(this.nativeKeyword, StringLiteral name) {
+  NativeClauseImpl(this.nativeKeyword, StringLiteralImpl name) {
     _name = _becomeParentOf(name);
   }
 
   @override
   Token get beginToken => nativeKeyword;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(nativeKeyword)..add(_name);
 
   @override
   Token get endToken => _name.endToken;
 
   @override
   StringLiteral get name => _name;
 
   @override
   void set name(StringLiteral name) {
-    _name = _becomeParentOf(name);
+    _name = _becomeParentOf(name as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitNativeClause(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _name?.accept(visitor);
   }
@@ skipping 24 matching lines @@
    * body.
    */
   @override
   Token semicolon;
 
   /**
    * Initialize a newly created function body consisting of the 'native' token,
    * a string literal, and a semicolon.
    */
   NativeFunctionBodyImpl(
-      this.nativeKeyword, StringLiteral stringLiteral, this.semicolon) {
+      this.nativeKeyword, StringLiteralImpl stringLiteral, this.semicolon) {
     _stringLiteral = _becomeParentOf(stringLiteral);
   }
 
   @override
   Token get beginToken => nativeKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(nativeKeyword)
     ..add(_stringLiteral)
     ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   StringLiteral get stringLiteral => _stringLiteral;
 
   @override
   void set stringLiteral(StringLiteral stringLiteral) {
-    _stringLiteral = _becomeParentOf(stringLiteral);
+    _stringLiteral = _becomeParentOf(stringLiteral as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitNativeFunctionBody(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _stringLiteral?.accept(visitor);
   }
@@ skipping 61 matching lines @@
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: $index, Size: ${_elements.length}");
     }
     return _elements[index];
   }
 
   void operator []=(int index, E node) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: $index, Size: ${_elements.length}");
     }
-    _owner._becomeParentOf(node);
+    _owner._becomeParentOf(node as AstNodeImpl);
     _elements[index] = node;
   }
 
   @override
   accept(AstVisitor visitor) {
     int length = _elements.length;
     for (var i = 0; i < length; i++) {
       _elements[i].accept(visitor);
     }
   }
 
   @override
   void add(E node) {
     insert(length, node);
   }
 
   @override
   bool addAll(Iterable<E> nodes) {
     if (nodes != null && !nodes.isEmpty) {
       _elements.addAll(nodes);
       for (E node in nodes) {
-        _owner._becomeParentOf(node);
+        _owner._becomeParentOf(node as AstNodeImpl);
       }
       return true;
     }
     return false;
   }
 
   @override
   void clear() {
     _elements = <E>[];
   }
 
   @override
   void insert(int index, E node) {
     int length = _elements.length;
     if (index < 0 || index > length) {
       throw new RangeError("Index: $index, Size: ${_elements.length}");
     }
-    _owner._becomeParentOf(node);
+    _owner._becomeParentOf(node as AstNodeImpl);
     if (length == 0) {
       _elements.add(node);
     } else {
       _elements.insert(index, node);
     }
   }
 
   @override
   E removeAt(int index) {
     if (index < 0 || index >= _elements.length) {
@@ skipping 29 matching lines @@
   /**
    * The name of the parameter being declared.
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute.
    */
-  NormalFormalParameterImpl(
-      Comment comment, List<Annotation> metadata, SimpleIdentifier identifier) {
+  NormalFormalParameterImpl(CommentImpl comment, List<Annotation> metadata,
+      SimpleIdentifierImpl identifier) {
     _comment = _becomeParentOf(comment);
     _metadata = new NodeListImpl<Annotation>(this, metadata);
     _identifier = _becomeParentOf(identifier);
   }
 
   @override
   Comment get documentationComment => _comment;
 
   @override
   void set documentationComment(Comment comment) {
-    _comment = _becomeParentOf(comment);
+    _comment = _becomeParentOf(comment as AstNodeImpl);
   }
 
   @override
   SimpleIdentifier get identifier => _identifier;
 
   @override
   void set identifier(SimpleIdentifier identifier) {
-    _identifier = _becomeParentOf(identifier);
+    _identifier = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   ParameterKind get kind {
     AstNode parent = this.parent;
     if (parent is DefaultFormalParameter) {
       return parent.kind;
     }
     return ParameterKind.REQUIRED;
   }
@@ skipping 111 matching lines @@
 
   /**
    * The right parenthesis.
    */
   Token rightParenthesis;
 
   /**
    * Initialize a newly created parenthesized expression.
    */
   ParenthesizedExpressionImpl(
-      this.leftParenthesis, Expression expression, this.rightParenthesis) {
+      this.leftParenthesis, ExpressionImpl expression, this.rightParenthesis) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => leftParenthesis;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(leftParenthesis)
     ..add(_expression)
     ..add(rightParenthesis);
 
   @override
   Token get endToken => rightParenthesis;
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => 15;
 
   @override
   Expression get unParenthesized {
     // This is somewhat inefficient, but it avoids a stack overflow in the
     // degenerate case.
     Expression expression = _expression;
@@ skipping 91 matching lines @@
    */
   @override
   Token semicolon;
 
   /**
    * Initialize a newly created part-of directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
   PartOfDirectiveImpl(
-      Comment comment,
+      CommentImpl comment,
       List<Annotation> metadata,
       this.partKeyword,
       this.ofKeyword,
-      LibraryIdentifier libraryName,
+      LibraryIdentifierImpl libraryName,
       this.semicolon)
       : super(comment, metadata) {
     _libraryName = _becomeParentOf(libraryName);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(partKeyword)
     ..add(ofKeyword)
     ..add(_libraryName)
     ..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => partKeyword;
 
   @override
   Token get keyword => partKeyword;
 
   @override
   LibraryIdentifier get libraryName => _libraryName;
 
   @override
   void set libraryName(LibraryIdentifier libraryName) {
-    _libraryName = _becomeParentOf(libraryName);
+    _libraryName = _becomeParentOf(libraryName as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitPartOfDirective(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _libraryName?.accept(visitor);
@@ skipping 32 matching lines @@
    * The element associated with the operator based on the static 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.
    */
   @override
   MethodElement staticElement;
 
   /**
    * Initialize a newly created postfix expression.
    */
-  PostfixExpressionImpl(Expression operand, this.operator) {
+  PostfixExpressionImpl(ExpressionImpl operand, this.operator) {
     _operand = _becomeParentOf(operand);
   }
 
   @override
   Token get beginToken => _operand.beginToken;
 
   @override
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_operand)..add(operator);
 
   @override
   Token get endToken => operator;
 
   @override
   Expression get operand => _operand;
 
   @override
   void set operand(Expression expression) {
-    _operand = _becomeParentOf(expression);
+    _operand = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => 15;
 
   /**
    * 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`.
@@ skipping 56 matching lines @@
   Token period;
 
   /**
    * The identifier being prefixed.
    */
   SimpleIdentifier _identifier;
 
   /**
    * Initialize a newly created prefixed identifier.
    */
-  PrefixedIdentifierImpl(
-      SimpleIdentifier prefix, this.period, SimpleIdentifier identifier) {
+  PrefixedIdentifierImpl(SimpleIdentifierImpl prefix, this.period,
+      SimpleIdentifierImpl identifier) {
     _prefix = _becomeParentOf(prefix);
     _identifier = _becomeParentOf(identifier);
   }
 
   /**
    * Initialize a newly created prefixed identifier that does not take ownership
    * of the components. The resulting node is only for temporary use, such as by
    * resolution.
    */
   PrefixedIdentifierImpl.temp(this._prefix, this._identifier) : period = null;
@@ skipping 14 matching lines @@
       new ChildEntities()..add(_prefix)..add(period)..add(_identifier);
 
   @override
   Token get endToken => _identifier.endToken;
 
   @override
   SimpleIdentifier get identifier => _identifier;
 
   @override
   void set identifier(SimpleIdentifier identifier) {
-    _identifier = _becomeParentOf(identifier);
+    _identifier = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   bool get isDeferred {
     Element element = _prefix.staticElement;
     if (element is PrefixElement) {
       List<ImportElement> imports =
           element.enclosingElement.getImportsWithPrefix(element);
       if (imports.length != 1) {
         return false;
       }
       return imports[0].isDeferred;
     }
     return false;
   }
 
   @override
   String get name => "${_prefix.name}.${_identifier.name}";
 
   @override
   int get precedence => 15;
 
   @override
   SimpleIdentifier get prefix => _prefix;
 
   @override
   void set prefix(SimpleIdentifier identifier) {
-    _prefix = _becomeParentOf(identifier);
+    _prefix = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   Element get propagatedElement {
     if (_identifier == null) {
       return null;
     }
     return _identifier.propagatedElement;
   }
 
@@ skipping 43 matching lines @@
   /**
    * 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.
    */
   MethodElement propagatedElement;
 
   /**
    * Initialize a newly created prefix expression.
    */
-  PrefixExpressionImpl(this.operator, Expression operand) {
+  PrefixExpressionImpl(this.operator, ExpressionImpl operand) {
     _operand = _becomeParentOf(operand);
   }
 
   @override
   Token get beginToken => operator;
 
   @override
   MethodElement get bestElement {
     MethodElement element = propagatedElement;
     if (element == null) {
       element = staticElement;
     }
     return element;
   }
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(operator)..add(_operand);
 
   @override
   Token get endToken => _operand.endToken;
 
   @override
   Expression get operand => _operand;
 
   @override
   void set operand(Expression expression) {
-    _operand = _becomeParentOf(expression);
+    _operand = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => 14;
 
   /**
    * 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`.
@@ skipping 59 matching lines @@
 
   /**
    * The name of the property being accessed.
    */
   SimpleIdentifier _propertyName;
 
   /**
    * Initialize a newly created property access expression.
    */
   PropertyAccessImpl(
-      Expression target, this.operator, SimpleIdentifier propertyName) {
+      ExpressionImpl target, this.operator, SimpleIdentifierImpl propertyName) {
     _target = _becomeParentOf(target);
     _propertyName = _becomeParentOf(propertyName);
   }
 
   @override
   Token get beginToken {
     if (_target != null) {
       return _target.beginToken;
     }
     return operator;
@@ skipping 14 matching lines @@
       operator != null && operator.type == TokenType.PERIOD_PERIOD;
 
   @override
   int get precedence => 15;
 
   @override
   SimpleIdentifier get propertyName => _propertyName;
 
   @override
   void set propertyName(SimpleIdentifier identifier) {
-    _propertyName = _becomeParentOf(identifier);
+    _propertyName = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   Expression get realTarget {
     if (isCascaded) {
       AstNode ancestor = parent;
       while (ancestor is! CascadeExpression) {
         if (ancestor == null) {
           return _target;
         }
         ancestor = ancestor.parent;
       }
       return (ancestor as CascadeExpression).target;
     }
     return _target;
   }
 
   @override
   Expression get target => _target;
 
   @override
   void set target(Expression expression) {
-    _target = _becomeParentOf(expression);
+    _target = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitPropertyAccess(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _target?.accept(visitor);
     _propertyName?.accept(visitor);
@@ skipping 37 matching lines @@
    * constructor could not be resolved.
    */
   ConstructorElement staticElement;
 
   /**
    * Initialize a newly created redirecting invocation to invoke the constructor
    * with the given name with the given arguments. The [constructorName] can be
    * `null` if the constructor being invoked is the unnamed constructor.
    */
   RedirectingConstructorInvocationImpl(this.thisKeyword, this.period,
-      SimpleIdentifier constructorName, ArgumentList argumentList) {
+      SimpleIdentifierImpl constructorName, ArgumentListImpl argumentList) {
     _constructorName = _becomeParentOf(constructorName);
     _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
   ArgumentList get argumentList => _argumentList;
 
   @override
   void set argumentList(ArgumentList argumentList) {
-    _argumentList = _becomeParentOf(argumentList);
+    _argumentList = _becomeParentOf(argumentList as AstNodeImpl);
   }
 
   @override
   Token get beginToken => thisKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(thisKeyword)
     ..add(period)
     ..add(_constructorName)
     ..add(_argumentList);
 
   @override
   SimpleIdentifier get constructorName => _constructorName;
 
   @override
   void set constructorName(SimpleIdentifier identifier) {
-    _constructorName = _becomeParentOf(identifier);
+    _constructorName = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   Token get endToken => _argumentList.endToken;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitRedirectingConstructorInvocation(this);
 
   @override
@@ skipping 64 matching lines @@
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created return statement. The [expression] can be `null`
    * if no explicit value was provided.
    */
   ReturnStatementImpl(
-      this.returnKeyword, Expression expression, this.semicolon) {
+      this.returnKeyword, ExpressionImpl expression, this.semicolon) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => returnKeyword;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(returnKeyword)..add(_expression)..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitReturnStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _expression?.accept(visitor);
   }
@@ skipping 96 matching lines @@
    * does not have a declared type.
    */
   TypeName _type;
 
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [keyword] can be `null` if a type was
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
-  SimpleFormalParameterImpl(Comment comment, List<Annotation> metadata,
-      this.keyword, TypeName type, SimpleIdentifier identifier)
+  SimpleFormalParameterImpl(CommentImpl comment, List<Annotation> metadata,
+      this.keyword, TypeNameImpl type, SimpleIdentifierImpl identifier)
       : super(comment, metadata, identifier) {
     _type = _becomeParentOf(type);
   }
 
   @override
   Token get beginToken {
     NodeList<Annotation> metadata = this.metadata;
     if (!metadata.isEmpty) {
       return metadata.beginToken;
     } else if (keyword != null) {
@@ skipping 15 matching lines @@
   bool get isConst => keyword?.keyword == Keyword.CONST;
 
   @override
   bool get isFinal => keyword?.keyword == Keyword.FINAL;
 
   @override
   TypeName get type => _type;
 
   @override
   void set type(TypeName typeName) {
-    _type = _becomeParentOf(typeName);
+    _type = _becomeParentOf(typeName as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitSimpleFormalParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _type?.accept(visitor);
@@ skipping 554 matching lines @@
    */
   ConstructorElement staticElement;
 
   /**
    * Initialize a newly created super invocation to invoke the inherited
    * constructor with the given name with the given arguments. The [period] and
    * [constructorName] can be `null` if the constructor being invoked is the
    * unnamed constructor.
    */
   SuperConstructorInvocationImpl(this.superKeyword, this.period,
-      SimpleIdentifier constructorName, ArgumentList argumentList) {
+      SimpleIdentifierImpl constructorName, ArgumentListImpl argumentList) {
     _constructorName = _becomeParentOf(constructorName);
     _argumentList = _becomeParentOf(argumentList);
   }
 
   @override
   ArgumentList get argumentList => _argumentList;
 
   @override
   void set argumentList(ArgumentList argumentList) {
-    _argumentList = _becomeParentOf(argumentList);
+    _argumentList = _becomeParentOf(argumentList as AstNodeImpl);
   }
 
   @override
   Token get beginToken => superKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(superKeyword)
     ..add(period)
     ..add(_constructorName)
     ..add(_argumentList);
 
   @override
   SimpleIdentifier get constructorName => _constructorName;
 
   @override
   void set constructorName(SimpleIdentifier identifier) {
-    _constructorName = _becomeParentOf(identifier);
+    _constructorName = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   Token get endToken => _argumentList.endToken;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitSuperConstructorInvocation(this);
 
   @override
@@ skipping 51 matching lines @@
 class SwitchCaseImpl extends SwitchMemberImpl implements SwitchCase {
   /**
    * The expression controlling whether the statements will be executed.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created switch case. The list of [labels] can be `null`
    * if there are no labels.
    */
-  SwitchCaseImpl(List<Label> labels, Token keyword, Expression expression,
+  SwitchCaseImpl(List<Label> labels, Token keyword, ExpressionImpl expression,
       Token colon, List<Statement> statements)
       : super(labels, keyword, colon, statements) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..addAll(labels)
     ..add(keyword)
     ..add(_expression)
     ..add(colon)
     ..addAll(statements);
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitSwitchCase(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     labels.accept(visitor);
     _expression?.accept(visitor);
@@ skipping 138 matching lines @@
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created switch statement. The list of [members] can be
    * `null` if there are no switch members.
    */
   SwitchStatementImpl(
       this.switchKeyword,
       this.leftParenthesis,
-      Expression expression,
+      ExpressionImpl expression,
       this.rightParenthesis,
       this.leftBracket,
       List<SwitchMember> members,
       this.rightBracket) {
     _expression = _becomeParentOf(expression);
     _members = new NodeListImpl<SwitchMember>(this, members);
   }
 
   @override
   Token get beginToken => switchKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(switchKeyword)
     ..add(leftParenthesis)
     ..add(_expression)
     ..add(rightParenthesis)
     ..add(leftBracket)
     ..addAll(_members)
     ..add(rightBracket);
 
   @override
   Token get endToken => rightBracket;
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   NodeList<SwitchMember> get members => _members;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitSwitchStatement(this);
 
   @override
@@ skipping 99 matching lines @@
   Token throwKeyword;
 
   /**
    * The expression computing the exception to be thrown.
    */
   Expression _expression;
 
   /**
    * Initialize a newly created throw expression.
    */
-  ThrowExpressionImpl(this.throwKeyword, Expression expression) {
+  ThrowExpressionImpl(this.throwKeyword, ExpressionImpl expression) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken => throwKeyword;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(throwKeyword)..add(_expression);
 
   @override
   Token get endToken {
     if (_expression != null) {
       return _expression.endToken;
     }
     return throwKeyword;
   }
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   int get precedence => 0;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitThrowExpression(this);
 
   @override
@@ skipping 19 matching lines @@
   /**
    * The semicolon terminating the declaration.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created top-level variable declaration. Either or both
    * of the [comment] and [metadata] can be `null` if the variable does not have
    * the corresponding attribute.
    */
-  TopLevelVariableDeclarationImpl(Comment comment, List<Annotation> metadata,
-      VariableDeclarationList variableList, this.semicolon)
+  TopLevelVariableDeclarationImpl(
+      CommentImpl comment,
+      List<Annotation> metadata,
+      VariableDeclarationListImpl variableList,
+      this.semicolon)
       : super(comment, metadata) {
     _variableList = _becomeParentOf(variableList);
   }
 
   @override
   Iterable get childEntities =>
       super._childEntities..add(_variableList)..add(semicolon);
 
   @override
   Element get element => null;
 
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => _variableList.beginToken;
 
   @override
   VariableDeclarationList get variables => _variableList;
 
   @override
   void set variables(VariableDeclarationList variables) {
-    _variableList = _becomeParentOf(variables);
+    _variableList = _becomeParentOf(variables as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitTopLevelVariableDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _variableList?.accept(visitor);
@@ skipping 35 matching lines @@
    * The finally block contained in the try statement, or `null` if the
    * statement does not contain a finally clause.
    */
   Block _finallyBlock;
 
   /**
    * Initialize a newly created try statement. The list of [catchClauses] can be
    * `null` if there are no catch clauses. The [finallyKeyword] and
    * [finallyBlock] can be `null` if there is no finally clause.
    */
-  TryStatementImpl(this.tryKeyword, Block body, List<CatchClause> catchClauses,
-      this.finallyKeyword, Block finallyBlock) {
+  TryStatementImpl(
+      this.tryKeyword,
+      BlockImpl body,
+      List<CatchClause> catchClauses,
+      this.finallyKeyword,
+      BlockImpl finallyBlock) {
     _body = _becomeParentOf(body);
     _catchClauses = new NodeListImpl<CatchClause>(this, catchClauses);
     _finallyBlock = _becomeParentOf(finallyBlock);
   }
 
   @override
   Token get beginToken => tryKeyword;
 
   @override
   Block get body => _body;
 
   @override
   void set body(Block block) {
-    _body = _becomeParentOf(block);
+    _body = _becomeParentOf(block as AstNodeImpl);
   }
 
   @override
   NodeList<CatchClause> get catchClauses => _catchClauses;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(tryKeyword)
     ..add(_body)
     ..addAll(_catchClauses)
@@ skipping 10 matching lines @@
       return _catchClauses.endToken;
     }
     return _body.endToken;
   }
 
   @override
   Block get finallyBlock => _finallyBlock;
 
   @override
   void set finallyBlock(Block block) {
-    _finallyBlock = _becomeParentOf(block);
+    _finallyBlock = _becomeParentOf(block as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitTryStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _body?.accept(visitor);
     _catchClauses.accept(visitor);
@@ skipping 113 matching lines @@
    * The type argument associated with this literal, or `null` if no type
    * arguments were declared.
    */
   TypeArgumentList _typeArguments;
 
   /**
    * Initialize a newly created typed literal. The [constKeyword] can be `null`\
    * if the literal is not a constant. The [typeArguments] can be `null` if no
    * type arguments were declared.
    */
-  TypedLiteralImpl(this.constKeyword, TypeArgumentList typeArguments) {
+  TypedLiteralImpl(this.constKeyword, TypeArgumentListImpl typeArguments) {
     _typeArguments = _becomeParentOf(typeArguments);
   }
 
   @override
   TypeArgumentList get typeArguments => _typeArguments;
 
   @override
   void set typeArguments(TypeArgumentList typeArguments) {
-    _typeArguments = _becomeParentOf(typeArguments);
+    _typeArguments = _becomeParentOf(typeArguments as AstNodeImpl);
   }
 
   ChildEntities get _childEntities =>
       new ChildEntities()..add(constKeyword)..add(_typeArguments);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _typeArguments?.accept(visitor);
   }
 }
@@ skipping 18 matching lines @@
 
   /**
    * The type being named, or `null` if the AST structure has not been resolved.
    */
   DartType type;
 
   /**
    * Initialize a newly created type name. The [typeArguments] can be `null` if
    * there are no type arguments.
    */
-  TypeNameImpl(Identifier name, TypeArgumentList typeArguments) {
+  TypeNameImpl(IdentifierImpl name, TypeArgumentListImpl typeArguments) {
     _name = _becomeParentOf(name);
     _typeArguments = _becomeParentOf(typeArguments);
   }
 
   @override
   Token get beginToken => _name.beginToken;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_name)..add(_typeArguments);
@@ skipping 16 matching lines @@
   }
 
   @override
   bool get isSynthetic => _name.isSynthetic && _typeArguments == null;
 
   @override
   Identifier get name => _name;
 
   @override
   void set name(Identifier identifier) {
-    _name = _becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   TypeArgumentList get typeArguments => _typeArguments;
 
   @override
   void set typeArguments(TypeArgumentList typeArguments) {
-    _typeArguments = _becomeParentOf(typeArguments);
+    _typeArguments = _becomeParentOf(typeArguments as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitTypeName(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _name?.accept(visitor);
     _typeArguments?.accept(visitor);
@@ skipping 23 matching lines @@
    * explicit upper bound.
    */
   TypeName _bound;
 
   /**
    * Initialize a newly created type parameter. Either or both of the [comment]
    * and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [extendsKeyword] and [bound] can be `null` if
    * the parameter does not have an upper bound.
    */
-  TypeParameterImpl(Comment comment, List<Annotation> metadata,
-      SimpleIdentifier name, this.extendsKeyword, TypeName bound)
+  TypeParameterImpl(CommentImpl comment, List<Annotation> metadata,
+      SimpleIdentifierImpl name, this.extendsKeyword, TypeNameImpl bound)
       : super(comment, metadata) {
     _name = _becomeParentOf(name);
     _bound = _becomeParentOf(bound);
   }
 
   @override
   TypeName get bound => _bound;
 
   @override
   void set bound(TypeName typeName) {
-    _bound = _becomeParentOf(typeName);
+    _bound = _becomeParentOf(typeName as AstNodeImpl);
   }
 
   @override
   Iterable get childEntities =>
       super._childEntities..add(_name)..add(extendsKeyword)..add(_bound);
 
   @override
   TypeParameterElement get element =>
       _name?.staticElement as TypeParameterElement;
 
   @override
   Token get endToken {
     if (_bound == null) {
       return _name.endToken;
     }
     return _bound.endToken;
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 
   @override
   SimpleIdentifier get name => _name;
 
   @override
   void set name(SimpleIdentifier identifier) {
-    _name = _becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitTypeParameter(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _name?.accept(visitor);
@@ skipping 86 matching lines @@
    * The source to which the URI was resolved.
    */
   Source source;
 
   /**
    * Initialize a newly create URI-based directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
   UriBasedDirectiveImpl(
-      Comment comment, List<Annotation> metadata, StringLiteral uri)
+      CommentImpl comment, List<Annotation> metadata, StringLiteralImpl uri)
       : super(comment, metadata) {
     _uri = _becomeParentOf(uri);
   }
 
   @override
   StringLiteral get uri => _uri;
 
   @override
   void set uri(StringLiteral uri) {
-    _uri = _becomeParentOf(uri);
+    _uri = _becomeParentOf(uri as AstNodeImpl);
   }
 
   @override
   UriValidationCode validate() {
     StringLiteral uriLiteral = uri;
     if (uriLiteral is StringInterpolation) {
       return UriValidationCode.URI_WITH_INTERPOLATION;
     }
     String uriContent = this.uriContent;
     if (uriContent == null) {
@@ skipping 73 matching lines @@
    * The expression used to compute the initial value for the variable, or
    * `null` if the initial value was not specified.
    */
   Expression _initializer;
 
   /**
    * Initialize a newly created variable declaration. The [equals] and
    * [initializer] can be `null` if there is no initializer.
    */
   VariableDeclarationImpl(
-      SimpleIdentifier name, this.equals, Expression initializer)
+      SimpleIdentifierImpl name, this.equals, ExpressionImpl initializer)
       : super(null, null) {
     _name = _becomeParentOf(name);
     _initializer = _becomeParentOf(initializer);
   }
 
   @override
   Iterable get childEntities =>
       super._childEntities..add(_name)..add(equals)..add(_initializer);
 
   /**
@@ skipping 25 matching lines @@
   }
 
   @override
   Token get firstTokenAfterCommentAndMetadata => _name.beginToken;
 
   @override
   Expression get initializer => _initializer;
 
   @override
   void set initializer(Expression expression) {
-    _initializer = _becomeParentOf(expression);
+    _initializer = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   bool get isConst {
     AstNode parent = this.parent;
     return parent is VariableDeclarationList && parent.isConst;
   }
 
   @override
   bool get isFinal {
     AstNode parent = this.parent;
     return parent is VariableDeclarationList && parent.isFinal;
   }
 
   @override
   SimpleIdentifier get name => _name;
 
   @override
   void set name(SimpleIdentifier identifier) {
-    _name = _becomeParentOf(identifier);
+    _name = _becomeParentOf(identifier as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitVariableDeclaration(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
     _name?.accept(visitor);
@@ skipping 30 matching lines @@
    * A list containing the individual variables being declared.
    */
   NodeList<VariableDeclaration> _variables;
 
   /**
    * Initialize a newly created variable declaration list. Either or both of the
    * [comment] and [metadata] can be `null` if the variable list does not have
    * the corresponding attribute. The [keyword] can be `null` if a type was
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
-  VariableDeclarationListImpl(Comment comment, List<Annotation> metadata,
-      this.keyword, TypeName type, List<VariableDeclaration> variables)
+  VariableDeclarationListImpl(CommentImpl comment, List<Annotation> metadata,
+      this.keyword, TypeNameImpl type, List<VariableDeclaration> variables)
       : super(comment, metadata) {
     _type = _becomeParentOf(type);
     _variables = new NodeListImpl<VariableDeclaration>(this, variables);
   }
 
   @override
   // TODO(paulberry): include commas.
   Iterable get childEntities => super._childEntities
     ..add(keyword)
     ..add(_type)
@@ skipping 16 matching lines @@
   bool get isConst => keyword?.keyword == Keyword.CONST;
 
   @override
   bool get isFinal => keyword?.keyword == Keyword.FINAL;
 
   @override
   TypeName get type => _type;
 
   @override
   void set type(TypeName typeName) {
-    _type = _becomeParentOf(typeName);
+    _type = _becomeParentOf(typeName as AstNodeImpl);
   }
 
   @override
   NodeList<VariableDeclaration> get variables => _variables;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitVariableDeclarationList(this);
 
   @override
@@ skipping 20 matching lines @@
 
   /**
    * The semicolon terminating the statement.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created variable declaration statement.
    */
   VariableDeclarationStatementImpl(
-      VariableDeclarationList variableList, this.semicolon) {
+      VariableDeclarationListImpl variableList, this.semicolon) {
     _variableList = _becomeParentOf(variableList);
   }
 
   @override
   Token get beginToken => _variableList.beginToken;
 
   @override
   Iterable get childEntities =>
       new ChildEntities()..add(_variableList)..add(semicolon);
 
   @override
   Token get endToken => semicolon;
 
   @override
   VariableDeclarationList get variables => _variableList;
 
   @override
   void set variables(VariableDeclarationList variables) {
-    _variableList = _becomeParentOf(variables);
+    _variableList = _becomeParentOf(variables as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitVariableDeclarationStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _variableList?.accept(visitor);
   }
@@ skipping 28 matching lines @@
 
   /**
    * The body of the loop.
    */
   Statement _body;
 
   /**
    * Initialize a newly created while statement.
    */
   WhileStatementImpl(this.whileKeyword, this.leftParenthesis,
-      Expression condition, this.rightParenthesis, Statement body) {
+      ExpressionImpl condition, this.rightParenthesis, StatementImpl body) {
     _condition = _becomeParentOf(condition);
     _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken => whileKeyword;
 
   @override
   Statement get body => _body;
 
   @override
   void set body(Statement statement) {
-    _body = _becomeParentOf(statement);
+    _body = _becomeParentOf(statement as AstNodeImpl);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(whileKeyword)
     ..add(leftParenthesis)
     ..add(_condition)
     ..add(rightParenthesis)
     ..add(_body);
 
   @override
   Expression get condition => _condition;
 
   @override
   void set condition(Expression expression) {
-    _condition = _becomeParentOf(expression);
+    _condition = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   Token get endToken => _body.endToken;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitWhileStatement(this);
 
   @override
@@ skipping 77 matching lines @@
   /**
    * The semicolon following the expression.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created yield expression. The [star] can be `null` if no
    * star was provided.
    */
   YieldStatementImpl(
-      this.yieldKeyword, this.star, Expression expression, this.semicolon) {
+      this.yieldKeyword, this.star, ExpressionImpl expression, this.semicolon) {
     _expression = _becomeParentOf(expression);
   }
 
   @override
   Token get beginToken {
     if (yieldKeyword != null) {
       return yieldKeyword;
     }
     return _expression.beginToken;
   }
@@ skipping 11 matching lines @@
       return semicolon;
     }
     return _expression.endToken;
   }
 
   @override
   Expression get expression => _expression;
 
   @override
   void set expression(Expression expression) {
-    _expression = _becomeParentOf(expression);
+    _expression = _becomeParentOf(expression as AstNodeImpl);
   }
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _expression?.accept(visitor);
   }
 }