Remove a cast by creating node lists directly

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 25 matching lines @@
   /**
    * The strings that are implicitly concatenated.
    */
   NodeList<StringLiteral> _strings;
 
   /**
    * Initialize a newly created list of adjacent strings. To be syntactically
    * valid, the list of [strings] must contain at least two elements.
    */
   AdjacentStringsImpl(List<StringLiteral> strings) {
-    _strings = new NodeList<StringLiteral>(this, strings);
+    _strings = new NodeListImpl<StringLiteral>(this, strings);
   }
 
   @override
   Token get beginToken => _strings.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()..addAll(_strings);
 
   @override
   Token get endToken => _strings.endToken;
@@ skipping 34 matching lines @@
    */
   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) {
     _comment = _becomeParentOf(comment);
-    _metadata = new NodeList<Annotation>(this, metadata);
+    _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) {
@@ skipping 253 matching lines @@
    * does not correspond to a formal parameter.
    */
   List<ParameterElement> _correspondingPropagatedParameters;
 
   /**
    * Initialize a newly created list of arguments. The list of [arguments] can
    * be `null` if there are no arguments.
    */
   ArgumentListImpl(
       this.leftParenthesis, List<Expression> arguments, this.rightParenthesis) {
-    _arguments = new NodeList<Expression>(this, arguments);
+    _arguments = new NodeListImpl<Expression>(this, arguments);
   }
 
   @override
   NodeList<Expression> get arguments => _arguments;
 
   @override
   Token get beginToken => leftParenthesis;
 
   @override
   // TODO(paulberry): Add commas.
@@ skipping 852 matching lines @@
   /**
    * The right curly bracket.
    */
   @override
   Token rightBracket;
 
   /**
    * Initialize a newly created block of code.
    */
   BlockImpl(this.leftBracket, List<Statement> statements, this.rightBracket) {
-    _statements = new NodeList<Statement>(this, statements);
+    _statements = new NodeListImpl<Statement>(this, statements);
   }
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(leftBracket)
     ..addAll(_statements)
     ..add(rightBracket);
@@ skipping 160 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) {
     _target = _becomeParentOf(target);
-    _cascadeSections = new NodeList<Expression>(this, cascadeSections);
+    _cascadeSections = new NodeListImpl<Expression>(this, cascadeSections);
   }
 
   @override
   Token get beginToken => _target.beginToken;
 
   @override
   NodeList<Expression> get cascadeSections => _cascadeSections;
 
   @override
   Iterable get childEntities => new ChildEntities()
@@ skipping 305 matching lines @@
       WithClause withClause,
       ImplementsClause 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 NodeList<ClassMember>(this, members);
+    _members = new NodeListImpl<ClassMember>(this, members);
   }
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(abstractKeyword)
     ..add(classKeyword)
     ..add(_name)
     ..add(_typeParameters)
     ..add(_extendsClause)
     ..add(_withClause)
@@ skipping 348 matching lines @@
    */
   NodeList<CommentReference> _references;
 
   /**
    * Initialize a newly created comment. The list of [tokens] must contain at
    * least one token. The [type] is the type of the comment. The list of
    * [references] can be empty if the comment does not contain any embedded
    * references.
    */
   CommentImpl(this.tokens, this._type, List<CommentReference> references) {
-    _references = new NodeList<CommentReference>(this, references);
+    _references = new NodeListImpl<CommentReference>(this, references);
   }
 
   @override
   Token get beginToken => tokens[0];
 
   @override
   Iterable get childEntities => new ChildEntities()..addAll(tokens);
 
   @override
   Token get endToken => tokens[tokens.length - 1];
@@ skipping 209 matching lines @@
    * 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,
       List<Directive> directives,
       List<CompilationUnitMember> declarations,
       this.endToken) {
     _scriptTag = _becomeParentOf(scriptTag);
-    _directives = new NodeList<Directive>(this, directives);
-    _declarations = new NodeList<CompilationUnitMember>(this, declarations);
+    _directives = new NodeListImpl<Directive>(this, directives);
+    _declarations = new NodeListImpl<CompilationUnitMember>(this, declarations);
   }
 
   @override
   Iterable get childEntities {
     ChildEntities result = new ChildEntities()..add(_scriptTag);
     if (_directivesAreBeforeDeclarations) {
       result..addAll(_directives)..addAll(_declarations);
     } else {
       result.addAll(sortedDirectivesAndDeclarations);
     }
@@ skipping 403 matching lines @@
       SimpleIdentifier name,
       FormalParameterList parameters,
       this.separator,
       List<ConstructorInitializer> initializers,
       ConstructorName redirectedConstructor,
       FunctionBody body)
       : super(comment, metadata) {
     _returnType = _becomeParentOf(returnType);
     _name = _becomeParentOf(name);
     _parameters = _becomeParentOf(parameters);
-    _initializers = new NodeList<ConstructorInitializer>(this, initializers);
+    _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);
@@ skipping 725 matching lines @@
 class DottedNameImpl extends AstNodeImpl implements DottedName {
   /**
    * The components of the identifier.
    */
   NodeList<SimpleIdentifier> _components;
 
   /**
    * Initialize a newly created dotted name.
    */
   DottedNameImpl(List<SimpleIdentifier> components) {
-    _components = new NodeList<SimpleIdentifier>(this, components);
+    _components = new NodeListImpl<SimpleIdentifier>(this, components);
   }
 
   @override
   Token get beginToken => _components.beginToken;
 
   @override
   // TODO(paulberry): add "." tokens.
   Iterable get childEntities => new ChildEntities()..addAll(_components);
 
   @override
@@ skipping 227 matching lines @@
    */
   EnumDeclarationImpl(
       Comment comment,
       List<Annotation> metadata,
       this.enumKeyword,
       SimpleIdentifier name,
       this.leftBracket,
       List<EnumConstantDeclaration> constants,
       this.rightBracket)
       : super(comment, metadata, name) {
-    _constants = new NodeList<EnumConstantDeclaration>(this, constants);
+    _constants = new NodeListImpl<EnumConstantDeclaration>(this, constants);
   }
 
   @override
   // TODO(brianwilkerson) Add commas?
   Iterable get childEntities => super._childEntities
     ..add(enumKeyword)
     ..add(_name)
     ..add(leftBracket)
     ..addAll(_constants)
     ..add(rightBracket);
@@ skipping 860 matching lines @@
    * Initialize a newly created parameter list. The list of [parameters] can be
    * `null` if there are no parameters. The [leftDelimiter] and [rightDelimiter]
    * can be `null` if there are no optional parameters.
    */
   FormalParameterListImpl(
       this.leftParenthesis,
       List<FormalParameter> parameters,
       this.leftDelimiter,
       this.rightDelimiter,
       this.rightParenthesis) {
-    _parameters = new NodeList<FormalParameter>(this, parameters);
+    _parameters = new NodeListImpl<FormalParameter>(this, parameters);
   }
 
   @override
   Token get beginToken => leftParenthesis;
 
   @override
   Iterable get childEntities {
     // TODO(paulberry): include commas.
     ChildEntities result = new ChildEntities()..add(leftParenthesis);
     bool leftDelimiterNeeded = leftDelimiter != null;
@@ skipping 120 matching lines @@
       Expression initialization,
       this.leftSeparator,
       Expression condition,
       this.rightSeparator,
       List<Expression> updaters,
       this.rightParenthesis,
       Statement body) {
     _variableList = _becomeParentOf(variableList);
     _initialization = _becomeParentOf(initialization);
     _condition = _becomeParentOf(condition);
-    _updaters = new NodeList<Expression>(this, updaters);
+    _updaters = new NodeListImpl<Expression>(this, updaters);
     _body = _becomeParentOf(body);
   }
 
   @override
   Token get beginToken => forKeyword;
 
   @override
   Statement get body => _body;
 
   @override
@@ skipping 694 matching lines @@
   /**
    * The list of names from the library that are hidden by this combinator.
    */
   NodeList<SimpleIdentifier> _hiddenNames;
 
   /**
    * Initialize a newly created import show combinator.
    */
   HideCombinatorImpl(Token keyword, List<SimpleIdentifier> hiddenNames)
       : super(keyword) {
-    _hiddenNames = new NodeList<SimpleIdentifier>(this, hiddenNames);
+    _hiddenNames = new NodeListImpl<SimpleIdentifier>(this, hiddenNames);
   }
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(keyword)
     ..addAll(_hiddenNames);
 
   @override
   Token get endToken => _hiddenNames.endToken;
 
@@ skipping 168 matching lines @@
 
   /**
    * The interfaces that are being implemented.
    */
   NodeList<TypeName> _interfaces;
 
   /**
    * Initialize a newly created implements clause.
    */
   ImplementsClauseImpl(this.implementsKeyword, List<TypeName> interfaces) {
-    _interfaces = new NodeList<TypeName>(this, interfaces);
+    _interfaces = new NodeListImpl<TypeName>(this, interfaces);
   }
 
   @override
   Token get beginToken => implementsKeyword;
 
   @override
   // TODO(paulberry): add commas.
   Iterable get childEntities => new ChildEntities()
     ..add(implementsKeyword)
     ..addAll(interfaces);
@@ skipping 746 matching lines @@
 
   /**
    * The statement with which the labels are being associated.
    */
   Statement _statement;
 
   /**
    * Initialize a newly created labeled statement.
    */
   LabeledStatementImpl(List<Label> labels, Statement statement) {
-    _labels = new NodeList<Label>(this, labels);
+    _labels = new NodeListImpl<Label>(this, labels);
     _statement = _becomeParentOf(statement);
   }
 
   @override
   Token get beginToken {
     if (!_labels.isEmpty) {
       return _labels.beginToken;
     }
     return _statement.beginToken;
   }
@@ skipping 160 matching lines @@
     implements LibraryIdentifier {
   /**
    * The components of the identifier.
    */
   NodeList<SimpleIdentifier> _components;
 
   /**
    * Initialize a newly created prefixed identifier.
    */
   LibraryIdentifierImpl(List<SimpleIdentifier> components) {
-    _components = new NodeList<SimpleIdentifier>(this, components);
+    _components = new NodeListImpl<SimpleIdentifier>(this, components);
   }
 
   @override
   Token get beginToken => _components.beginToken;
 
   @override
   Element get bestElement => staticElement;
 
   @override
   // TODO(paulberry): add "." tokens.
@@ skipping 65 matching lines @@
 
   /**
    * Initialize a newly created list literal. The [constKeyword] can be `null`
    * if the literal is not a constant. The [typeArguments] can be `null` if no
    * type arguments were declared. The list of [elements] can be `null` if the
    * list is empty.
    */
   ListLiteralImpl(Token constKeyword, TypeArgumentList typeArguments,
       this.leftBracket, List<Expression> elements, this.rightBracket)
       : super(constKeyword, typeArguments) {
-    _elements = new NodeList<Expression>(this, elements);
+    _elements = new NodeListImpl<Expression>(this, elements);
   }
 
   @override
   Token get beginToken {
     if (constKeyword != null) {
       return constKeyword;
     }
     TypeArgumentList typeArguments = this.typeArguments;
     if (typeArguments != null) {
       return typeArguments.beginToken;
@@ skipping 156 matching lines @@
   Token rightBracket;
 
   /**
    * Initialize a newly created map literal. The [constKeyword] can be `null` if
    * the literal is not a constant. The [typeArguments] can be `null` if no type
    * arguments were declared. The [entries] can be `null` if the map is empty.
    */
   MapLiteralImpl(Token constKeyword, TypeArgumentList typeArguments,
       this.leftBracket, List<MapLiteralEntry> entries, this.rightBracket)
       : super(constKeyword, typeArguments) {
-    _entries = new NodeList<MapLiteralEntry>(this, entries);
+    _entries = new NodeListImpl<MapLiteralEntry>(this, entries);
   }
 
   @override
   Token get beginToken {
     if (constKeyword != null) {
       return constKeyword;
     }
     TypeArgumentList typeArguments = this.typeArguments;
     if (typeArguments != null) {
       return typeArguments.beginToken;
@@ skipping 506 matching lines @@
    */
   NamespaceDirectiveImpl(
       Comment comment,
       List<Annotation> metadata,
       this.keyword,
       StringLiteral libraryUri,
       List<Configuration> configurations,
       List<Combinator> combinators,
       this.semicolon)
       : super(comment, metadata, libraryUri) {
-    _configurations = new NodeList<Configuration>(this, configurations);
-    _combinators = new NodeList<Combinator>(this, combinators);
+    _configurations = new NodeListImpl<Configuration>(this, configurations);
+    _combinators = new NodeListImpl<Combinator>(this, combinators);
   }
 
   @override
   NodeList<Combinator> get combinators => _combinators;
 
   @override
   NodeList<Configuration> get configurations => _configurations;
 
   @override
   Token get endToken => semicolon;
@@ skipping 279 matching lines @@
   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) {
     _comment = _becomeParentOf(comment);
-    _metadata = new NodeList<Annotation>(this, metadata);
+    _metadata = new NodeListImpl<Annotation>(this, metadata);
     _identifier = _becomeParentOf(identifier);
   }
 
   @override
   Comment get documentationComment => _comment;
 
   @override
   void set documentationComment(Comment comment) {
     _comment = _becomeParentOf(comment);
   }
@@ skipping 1000 matching lines @@
   /**
    * The list of names from the library that are made visible by this combinator.
    */
   NodeList<SimpleIdentifier> _shownNames;
 
   /**
    * Initialize a newly created import show combinator.
    */
   ShowCombinatorImpl(Token keyword, List<SimpleIdentifier> shownNames)
       : super(keyword) {
-    _shownNames = new NodeList<SimpleIdentifier>(this, shownNames);
+    _shownNames = new NodeListImpl<SimpleIdentifier>(this, shownNames);
   }
 
   @override
   // TODO(paulberry): add commas.
   Iterable get childEntities => new ChildEntities()
     ..add(keyword)
     ..addAll(_shownNames);
 
   @override
   Token get endToken => _shownNames.endToken;
@@ skipping 415 matching lines @@
     implements StringInterpolation {
   /**
    * The elements that will be composed to produce the resulting string.
    */
   NodeList<InterpolationElement> _elements;
 
   /**
    * Initialize a newly created string interpolation expression.
    */
   StringInterpolationImpl(List<InterpolationElement> elements) {
-    _elements = new NodeList<InterpolationElement>(this, elements);
+    _elements = new NodeListImpl<InterpolationElement>(this, elements);
   }
 
   @override
   Token get beginToken => _elements.beginToken;
 
   @override
   Iterable get childEntities => new ChildEntities()..addAll(_elements);
 
   @override
   int get contentsEnd {
@@ skipping 407 matching lines @@
    * The statements that will be executed if this switch member is selected.
    */
   NodeList<Statement> _statements;
 
   /**
    * Initialize a newly created switch member. The list of [labels] can be
    * `null` if there are no labels.
    */
   SwitchMemberImpl(List<Label> labels, this.keyword, this.colon,
       List<Statement> statements) {
-    _labels = new NodeList<Label>(this, labels);
-    _statements = new NodeList<Statement>(this, statements);
+    _labels = new NodeListImpl<Label>(this, labels);
+    _statements = new NodeListImpl<Statement>(this, statements);
   }
 
   @override
   Token get beginToken {
     if (!_labels.isEmpty) {
       return _labels.beginToken;
     }
     return keyword;
   }
 
@@ skipping 61 matching lines @@
    */
   SwitchStatementImpl(
       this.switchKeyword,
       this.leftParenthesis,
       Expression expression,
       this.rightParenthesis,
       this.leftBracket,
       List<SwitchMember> members,
       this.rightBracket) {
     _expression = _becomeParentOf(expression);
-    _members = new NodeList<SwitchMember>(this, members);
+    _members = new NodeListImpl<SwitchMember>(this, members);
   }
 
   @override
   Token get beginToken => switchKeyword;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(switchKeyword)
     ..add(leftParenthesis)
     ..add(_expression)
@@ skipping 270 matching lines @@
   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) {
     _body = _becomeParentOf(body);
-    _catchClauses = new NodeList<CatchClause>(this, catchClauses);
+    _catchClauses = new NodeListImpl<CatchClause>(this, catchClauses);
     _finallyBlock = _becomeParentOf(finallyBlock);
   }
 
   @override
   Token get beginToken => tryKeyword;
 
   @override
   Block get body => _body;
 
   @override
@@ skipping 102 matching lines @@
   /**
    * The right bracket.
    */
   Token rightBracket;
 
   /**
    * Initialize a newly created list of type arguments.
    */
   TypeArgumentListImpl(
       this.leftBracket, List<TypeName> arguments, this.rightBracket) {
-    _arguments = new NodeList<TypeName>(this, arguments);
+    _arguments = new NodeListImpl<TypeName>(this, arguments);
   }
 
   @override
   NodeList<TypeName> get arguments => _arguments;
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   // TODO(paulberry): Add commas.
@@ skipping 251 matching lines @@
   /**
    * The right angle bracket.
    */
   final Token rightBracket;
 
   /**
    * Initialize a newly created list of type parameters.
    */
   TypeParameterListImpl(
       this.leftBracket, List<TypeParameter> typeParameters, this.rightBracket) {
-    _typeParameters = new NodeList<TypeParameter>(this, typeParameters);
+    _typeParameters = new NodeListImpl<TypeParameter>(this, typeParameters);
   }
 
   @override
   Token get beginToken => leftBracket;
 
   @override
   Iterable get childEntities => new ChildEntities()
     ..add(leftBracket)
     ..addAll(_typeParameters)
     ..add(rightBracket);
@@ skipping 269 matching lines @@
   /**
    * 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)
       : super(comment, metadata) {
     _type = _becomeParentOf(type);
-    _variables = new NodeList<VariableDeclaration>(this, variables);
+    _variables = new NodeListImpl<VariableDeclaration>(this, variables);
   }
 
   @override
   // TODO(paulberry): include commas.
   Iterable get childEntities => super._childEntities
     ..add(keyword)
     ..add(_type)
     ..addAll(_variables);
 
   @override
@@ skipping 189 matching lines @@
 
   /**
    * The names of the mixins that were specified.
    */
   NodeList<TypeName> _mixinTypes;
 
   /**
    * Initialize a newly created with clause.
    */
   WithClauseImpl(this.withKeyword, List<TypeName> mixinTypes) {
-    _mixinTypes = new NodeList<TypeName>(this, mixinTypes);
+    _mixinTypes = new NodeListImpl<TypeName>(this, mixinTypes);
   }
 
   @override
   Token get beginToken => withKeyword;
 
   @override
   // TODO(paulberry): add commas.
   Iterable get childEntities => new ChildEntities()
     ..add(withKeyword)
     ..addAll(_mixinTypes);
@@ skipping 83 matching lines @@
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _expression?.accept(visitor);
   }
 }