Convert some for-in loops for performance

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 51 matching lines @@
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitAdjacentStrings(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _strings.accept(visitor);
   }
 
   @override
   void _appendStringValue(StringBuffer buffer) {
-    for (StringLiteralImpl stringLiteral in strings) {
+    int length = strings.length;
+    for (int i = 0; i < length; i++) {
+      StringLiteralImpl stringLiteral = strings[i];
       stringLiteral._appendStringValue(buffer);
     }
   }
 }
 
 /**
  * An AST node that can be annotated with both a documentation comment and a
  * list of annotations.
  */
 abstract class AnnotatedNodeImpl extends AstNodeImpl implements AnnotatedNode {
@@ skipping 69 matching lines @@
     }
     return result;
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     if (_commentIsBeforeAnnotations()) {
       _comment?.accept(visitor);
       _metadata.accept(visitor);
     } else {
-      for (AstNode child in sortedCommentAndAnnotations) {
-        child.accept(visitor);
+      List<AstNode> children = sortedCommentAndAnnotations;
+      int length = children.length;
+      for (int i = 0; i < length; i++) {
+        children[i].accept(visitor);
       }
     }
   }
 
   /**
    * Return `true` if there are no annotations before the comment. Note that a
    * result of `true` does not imply that there is a comment, nor that there are
    * annotations associated with this node.
    */
   bool _commentIsBeforeAnnotations() {
@@ skipping 1656 matching lines @@
   void set withClause(WithClause 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) {
+    int length = _members.length;
+    for (int i = 0; i < length; i++) {
+      ClassMember classMember = _members[i];
       if (classMember is ConstructorDeclaration) {
         ConstructorDeclaration constructor = classMember;
         SimpleIdentifier constructorName = constructor.name;
         if (name == null && constructorName == null) {
           return constructor;
         }
         if (constructorName != null && constructorName.name == name) {
           return constructor;
         }
       }
     }
     return null;
   }
 
   @override
   VariableDeclaration getField(String name) {
-    for (ClassMember classMember in _members) {
+    int memberLength = _members.length;
+    for (int i = 0; i < memberLength; i++) {
+      ClassMember classMember = _members[i];
       if (classMember is FieldDeclaration) {
         FieldDeclaration fieldDeclaration = classMember;
         NodeList<VariableDeclaration> fields =
             fieldDeclaration.fields.variables;
-        for (VariableDeclaration field in fields) {
+        int fieldLength = fields.length;
+        for (int i = 0; i < fieldLength; i++) {
+          VariableDeclaration field = fields[i];
           SimpleIdentifier fieldName = field.name;
           if (fieldName != null && name == fieldName.name) {
             return field;
           }
         }
       }
     }
     return null;
   }
 
   @override
   MethodDeclaration getMethod(String name) {
-    for (ClassMember classMember in _members) {
+    int length = _members.length;
+    for (int i = 0; i < length; i++) {
+      ClassMember classMember = _members[i];
       if (classMember is MethodDeclaration) {
         MethodDeclaration method = classMember;
         SimpleIdentifier methodName = method.name;
         if (methodName != null && name == methodName.name) {
           return method;
         }
       }
     }
     return null;
   }
@@ skipping 533 matching lines @@
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitCompilationUnit(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _scriptTag?.accept(visitor);
     if (_directivesAreBeforeDeclarations) {
       _directives.accept(visitor);
       _declarations.accept(visitor);
     } else {
-      for (AstNode child in sortedDirectivesAndDeclarations) {
+      int length = sortedDirectivesAndDeclarations.length;
+      for (int i = 0; i < length; i++) {
+        AstNode child = sortedDirectivesAndDeclarations[i];
         child.accept(visitor);
       }
     }
   }
 }
 
 /**
  * A node that declares one or more names within the scope of a compilation
  * unit.
  *
@@ skipping 2224 matching lines @@
   }
 
   @override
   Token get beginToken => leftParenthesis;
 
   @override
   Iterable get childEntities {
     // TODO(paulberry): include commas.
     ChildEntities result = new ChildEntities()..add(leftParenthesis);
     bool leftDelimiterNeeded = leftDelimiter != null;
-    for (FormalParameter parameter in _parameters) {
+    int length = _parameters.length;
+    for (int i = 0; i < length; i++) {
+      FormalParameter parameter = _parameters[i];
       if (leftDelimiterNeeded && leftDelimiter.offset < parameter.offset) {
         result.add(leftDelimiter);
         leftDelimiterNeeded = false;
       }
       result.add(parameter);
     }
     return result..add(rightDelimiter)..add(rightParenthesis);
   }
 
   @override
@@ skipping 1984 matching lines @@
   @override
   NodeList<SimpleIdentifier> get components => _components;
 
   @override
   Token get endToken => _components.endToken;
 
   @override
   String get name {
     StringBuffer buffer = new StringBuffer();
     bool needsPeriod = false;
-    for (SimpleIdentifier identifier in _components) {
+    int length = _components.length;
+    for (int i = 0; i < length; i++) {
+      SimpleIdentifier identifier = _components[i];
       if (needsPeriod) {
         buffer.write(".");
       } else {
         needsPeriod = true;
       }
       buffer.write(identifier.name);
     }
     return buffer.toString();
   }
 
@@ skipping 975 matching lines @@
   }
 
   @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 as AstNodeImpl);
+      if (nodes is List<E>) {
+        int length = nodes.length;
+        for (int i = 0; i < length; i++) {
+          E node = nodes[i];
+          _elements.add(node);
+          _owner._becomeParentOf(node as AstNodeImpl);
+        }
+      } else {
+        for (E node in nodes) {
+          _elements.add(node);
+          _owner._becomeParentOf(node as AstNodeImpl);
+        }
       }
       return true;
     }
     return false;
   }
 
   @override
   void clear() {
     _elements = <E>[];
   }
@@ skipping 118 matching lines @@
   @override
   void visitChildren(AstVisitor visitor) {
     //
     // Note that subclasses are responsible for visiting the identifier because
     // they often need to visit other nodes before visiting the identifier.
     //
     if (_commentIsBeforeAnnotations()) {
       _comment?.accept(visitor);
       _metadata.accept(visitor);
     } else {
-      for (AstNode child in sortedCommentAndAnnotations) {
-        child.accept(visitor);
+      List<AstNode> children = sortedCommentAndAnnotations;
+      int length = children.length;
+      for (int i = 0; i < length; i++) {
+        children[i].accept(visitor);
       }
     }
   }
 
   /**
    * Return `true` if the comment is lexically before any annotations.
    */
   bool _commentIsBeforeAnnotations() {
     if (_comment == null || _metadata.isEmpty) {
       return true;
@@ skipping 3175 matching lines @@
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _expression?.accept(visitor);
   }
 }