Convert some for-in loops for performance

pkg/analyzer/lib/src/task/dart.dart

 // Copyright (c) 2015, 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.task.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 1216 matching lines @@
   void internalPerform() {
     //
     // Prepare inputs.
     //
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     //
     // Build the enum members if they have not already been created.
     //
     EnumDeclaration findFirstEnum() {
-      for (CompilationUnitMember member in unit.declarations) {
+      NodeList<CompilationUnitMember> members = unit.declarations;
+      int length = members.length;
+      for (int i = 0; i < length; i++) {
+        CompilationUnitMember member = members[i];
         if (member is EnumDeclaration) {
           return member;
         }
       }
       return null;
     }
     EnumDeclaration firstEnum = findFirstEnum();
     if (firstEnum != null && firstEnum.element.accessors.isEmpty) {
       EnumMemberBuilder builder = new EnumMemberBuilder(typeProvider);
       unit.accept(builder);
@@ skipping 152 matching lines @@
     CompilationUnit definingCompilationUnit =
         getRequiredInput(DEFINING_UNIT_INPUT);
     List<CompilationUnit> partUnits = getRequiredInput(PARTS_UNIT_INPUT);
     //
     // Process inputs.
     //
     CompilationUnitElementImpl definingCompilationUnitElement =
         definingCompilationUnit.element;
     Map<Source, CompilationUnit> partUnitMap =
         new HashMap<Source, CompilationUnit>();
-    for (CompilationUnit partUnit in partUnits) {
+    int partLength = partUnits.length;
+    for (int i = 0; i < partLength; i++) {
+      CompilationUnit partUnit = partUnits[i];
       Source partSource = partUnit.element.source;
       partUnitMap[partSource] = partUnit;
     }
     //
     // Update "part" directives.
     //
     LibraryIdentifier libraryNameNode = null;
     String partsLibraryName = _UNKNOWN_LIBRARY_NAME;
     bool hasPartDirective = false;
     FunctionElement entryPoint =
         _findEntryPoint(definingCompilationUnitElement);
     List<Directive> directivesToResolve = <Directive>[];
     List<CompilationUnitElementImpl> sourcedCompilationUnits =
         <CompilationUnitElementImpl>[];
-    for (Directive directive in definingCompilationUnit.directives) {
+    NodeList<Directive> directives = definingCompilationUnit.directives;
+    int directiveLength = directives.length;
+    for (int i = 0; i < directiveLength; i++) {
+      Directive directive = directives[i];
       if (directive is LibraryDirective) {
         libraryNameNode = directive.name;
         directivesToResolve.add(directive);
       } else if (directive is PartDirective) {
         StringLiteral partUri = directive.uri;
         Source partSource = directive.source;
         hasPartDirective = true;
         CompilationUnit partUnit = partUnitMap[partSource];
         if (partUnit != null) {
           CompilationUnitElementImpl partElement = partUnit.element;
@@ skipping 90 matching lines @@
         setElementDocumentationComment(
             libraryElement, definingCompilationUnit.directives.first);
       }
     }
     //
     // Resolve the relevant directives to the library element.
     //
     // TODO(brianwilkerson) This updates the state of the AST structures but
     // does not associate a new result with it.
     //
-    for (Directive directive in directivesToResolve) {
+    int length = directivesToResolve.length;
+    for (int i = 0; i < length; i++) {
+      Directive directive = directivesToResolve[i];
       directive.element = libraryElement;
     }
     //
     // Record outputs.
     //
     outputs[BUILD_LIBRARY_ERRORS] = errors;
     outputs[LIBRARY_ELEMENT1] = libraryElement;
     outputs[IS_LAUNCHABLE] = entryPoint != null;
   }
 
   /**
    * Return the top-level [FunctionElement] entry point, or `null` if the given
    * [element] does not define an entry point.
    */
   FunctionElement _findEntryPoint(CompilationUnitElementImpl element) {
-    for (FunctionElement function in element.functions) {
+    List<FunctionElement> functions = element.functions;
+    int length = functions.length;
+    for (int i = 0; i < length; i++) {
+      FunctionElement function = functions[i];
       if (function.isEntryPoint) {
         return function;
       }
     }
     return null;
   }
 
   /**
    * Return the name of the library that the given part is declared to be a
    * part of, or `null` if the part does not contain a part-of directive.
    */
   String _getPartLibraryName(Source partSource, CompilationUnit partUnit,
       List<Directive> directivesToResolve) {
-    for (Directive directive in partUnit.directives) {
+    NodeList<Directive> directives = partUnit.directives;
+    int length = directives.length;
+    for (int i = 0; i < length; i++) {
+      Directive directive = directives[i];
       if (directive is PartOfDirective) {
         directivesToResolve.add(directive);
         LibraryIdentifier libraryName = directive.libraryName;
         if (libraryName != null) {
           return libraryName.name;
         }
       }
     }
     return null;
   }
 
   /**
    * Return `true` if the given compilation [unit] contains at least one
    * import directive with a `dart-ext:` URI.
    */
   bool _hasExtUri(CompilationUnit unit) {
-    for (Directive directive in unit.directives) {
+    NodeList<Directive> directives = unit.directives;
+    int length = directives.length;
+    for (int i = 0; i < length; i++) {
+      Directive directive = directives[i];
       if (directive is ImportDirective) {
         if (DartUriResolver.isDartExtUri(directive.uriContent)) {
           return true;
         }
       }
     }
     return false;
   }
 
   /**
@@ skipping 320 matching lines @@
     // cycle.
     //
     ConstantEvaluationEngine constantEvaluationEngine =
         new ConstantEvaluationEngine(typeProvider, context.declaredVariables,
             typeSystem: context.typeSystem);
     if (dependencyCycle == null) {
       constantEvaluationEngine.computeConstantValue(constant);
     } else {
       List<ConstantEvaluationTarget> constantsInCycle =
           <ConstantEvaluationTarget>[];
-      for (WorkItem workItem in dependencyCycle) {
+      int length = dependencyCycle.length;
+      for (int i = 0; i < length; i++) {
+        WorkItem workItem = dependencyCycle[i];
         if (workItem.descriptor == DESCRIPTOR) {
           constantsInCycle.add(workItem.target);
         }
       }
       assert(constantsInCycle.isNotEmpty);
       constantEvaluationEngine.generateCycleError(constantsInCycle, constant);
     }
     //
     // Record outputs.
     //
@@ skipping 162 matching lines @@
     if (context.analysisOptions.strongMode) {
       LibraryElement library = getRequiredInput(LIBRARY_ELEMENT_INPUT);
       List<LibraryElement> component = library.libraryCycle;
       Set<LibraryElement> filter = new Set<LibraryElement>.from(component);
       Set<CompilationUnitElement> deps = new Set<CompilationUnitElement>();
       void addLibrary(LibraryElement l) {
         if (!filter.contains(l)) {
           deps.addAll(l.units);
         }
       }
-      for (LibraryElement l in component) {
-        l.importedLibraries.forEach(addLibrary);
-        l.exportedLibraries.forEach(addLibrary);
+      int length = component.length;
+      for (int i = 0; i < length; i++) {
+        LibraryElement library = component[i];
+        library.importedLibraries.forEach(addLibrary);
+        library.exportedLibraries.forEach(addLibrary);
       }
       //
       // Record outputs.
       //
       outputs[LIBRARY_CYCLE] = component;
       outputs[LIBRARY_CYCLE_UNITS] = component.expand((l) => l.units).toList();
       outputs[LIBRARY_CYCLE_DEPENDENCIES] = deps.toList();
     } else {
       outputs[LIBRARY_CYCLE] = [];
       outputs[LIBRARY_CYCLE_UNITS] = [];
@@ skipping 258 matching lines @@
         }
         return DeltaResult.KEEP_CONTINUE;
       }
       return DeltaResult.INVALIDATE;
     }
     // Use the target library dependency information to decide whether
     // the delta affects the library.
     if (targetSource != null) {
       List<Source> librarySources =
           context.getLibrariesContaining(targetSource);
-      for (Source librarySource in librarySources) {
+      int length = librarySources.length;
+      for (int i = 0; i < length; i++) {
+        Source librarySource = librarySources[i];
         AnalysisCache cache = context.analysisCache;
         ReferencedNames referencedNames =
             cache.getValue(librarySource, REFERENCED_NAMES);
         if (referencedNames == null) {
           return DeltaResult.INVALIDATE;
         }
         referencedNames.addChangedElements(this);
         if (referencedNames.isAffectedBy(this)) {
           return DeltaResult.INVALIDATE;
         }
@@ skipping 37 matching lines @@
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     List<List<AnalysisError>> errorLists = <List<AnalysisError>>[];
     //
     // Prepare inputs.
     //
     EnginePlugin enginePlugin = AnalysisEngine.instance.enginePlugin;
-    for (ResultDescriptor result in enginePlugin.dartErrorsForSource) {
+    List<ResultDescriptor> errorsForSource = enginePlugin.dartErrorsForSource;
+    int sourceLength = errorsForSource.length;
+    for (int i = 0; i < sourceLength; i++) {
+      ResultDescriptor result = errorsForSource[i];
       String inputName = result.name + '_input';
       errorLists.add(getRequiredInput(inputName));
     }
-    for (ResultDescriptor result in enginePlugin.dartErrorsForUnit) {
+    List<ResultDescriptor> errorsForUnit = enginePlugin.dartErrorsForUnit;
+    int unitLength = errorsForUnit.length;
+    for (int i = 0; i < unitLength; i++) {
+      ResultDescriptor result = errorsForUnit[i];
       String inputName = result.name + '_input';
       Map<Source, List<AnalysisError>> errorMap = getRequiredInput(inputName);
       for (List<AnalysisError> errors in errorMap.values) {
         errorLists.add(errors);
       }
     }
 
     //
     // Filter ignored errors.
     //
@@ skipping 76 matching lines @@
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     Source source = target;
     Map<String, TaskInput> inputs = <String, TaskInput>{};
     inputs[LINE_INFO_INPUT] = LINE_INFO.of(source);
     inputs[PARSED_UNIT_INPUT] = PARSED_UNIT.of(source);
     EnginePlugin enginePlugin = AnalysisEngine.instance.enginePlugin;
     // for Source
-    for (ResultDescriptor result in enginePlugin.dartErrorsForSource) {
+    List<ResultDescriptor> errorsForSource = enginePlugin.dartErrorsForSource;
+    int sourceLength = errorsForSource.length;
+    for (int i = 0; i < sourceLength; i++) {
+      ResultDescriptor result = errorsForSource[i];
       String inputName = result.name + '_input';
       inputs[inputName] = result.of(source);
     }
     // for LibrarySpecificUnit
-    for (ResultDescriptor result in enginePlugin.dartErrorsForUnit) {
+    List<ResultDescriptor> errorsForUnit = enginePlugin.dartErrorsForUnit;
+    int unitLength = errorsForUnit.length;
+    for (int i = 0; i < unitLength; i++) {
+      ResultDescriptor result = errorsForUnit[i];
       String inputName = result.name + '_input';
       inputs[inputName] =
           CONTAINING_LIBRARIES.of(source).toMap((Source library) {
         LibrarySpecificUnit unit = new LibrarySpecificUnit(library, source);
         return result.of(unit);
       });
     }
     return inputs;
   }
 
@@ skipping 366 matching lines @@
     //
     CompilationUnit unit = getRequiredInput(RESOLVED_UNIT_INPUT);
 
     //
     // Generate lints.
     //
     List<AstVisitor> visitors = <AstVisitor>[];
 
     bool timeVisits = analysisOptions.enableTiming;
     List<Linter> linters = getLints(context);
-    for (Linter linter in linters) {
+    int length = linters.length;
+    for (int i = 0; i < length; i++) {
+      Linter linter = linters[i];
       AstVisitor visitor = linter.getVisitor();
       if (visitor != null) {
         linter.reporter = errorReporter;
         if (timeVisits) {
           visitor = new TimedAstVisitor(visitor, lintRegistry.getTimer(linter));
         }
         visitors.add(visitor);
       }
     }
 
@@ skipping 629 matching lines @@
     parser.parseGenericMethods = options.enableGenericMethods;
     parser.parseGenericMethodComments = options.strongMode;
     CompilationUnit unit = parser.parseCompilationUnit(tokenStream);
     unit.lineInfo = lineInfo;
 
     bool hasNonPartOfDirective = false;
     bool hasPartOfDirective = false;
     HashSet<Source> explicitlyImportedSourceSet = new HashSet<Source>();
     HashSet<Source> exportedSourceSet = new HashSet<Source>();
     HashSet<Source> includedSourceSet = new HashSet<Source>();
-    for (Directive directive in unit.directives) {
+    NodeList<Directive> directives = unit.directives;
+    int length = directives.length;
+    for (int i = 0; i < length; i++) {
+      Directive directive = directives[i];
       if (directive is PartOfDirective) {
         hasPartOfDirective = true;
       } else {
         hasNonPartOfDirective = true;
         if (directive is UriBasedDirective) {
           Source referencedSource =
               resolveDirective(context, source, directive, errorListener);
           if (referencedSource != null) {
             if (directive is ExportDirective) {
               exportedSourceSet.add(referencedSource);
@@ skipping 1059 matching lines @@
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     LibraryElement library = getRequiredInput(LIBRARY_INPUT);
     List<CompilationUnit> units = getRequiredInput(UNITS_INPUT);
     // Compute referenced names.
     ReferencedNames referencedNames = new ReferencedNames();
-    for (CompilationUnit unit in units) {
-      new ReferencedNamesBuilder(referencedNames).build(unit);
+    int length = units.length;
+    for (int i = 0; i < length; i++) {
+      new ReferencedNamesBuilder(referencedNames).build(units[i]);
     }
     //
     // Record outputs.
     //
     outputs[LIBRARY_ELEMENT9] = library;
     outputs[REFERENCED_NAMES] = referencedNames;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
@@ skipping 907 matching lines @@
     // Record outputs.
     //
     outputs[VERIFY_ERRORS] = getUniqueErrors(errorListener.errors);
   }
 
   /**
    * Check each directive in the given [unit] to see if the referenced source
    * exists and report an error if it does not.
    */
   void validateDirectives(CompilationUnit unit) {
-    for (Directive directive in unit.directives) {
+    NodeList<Directive> directives = unit.directives;
+    int length = directives.length;
+    for (int i = 0; i < length; i++) {
+      Directive directive = directives[i];
       if (directive is UriBasedDirective) {
         validateReferencedSource(directive);
       }
     }
   }
 
   /**
    * Check the given [directive] to see if the referenced source exists and
    * report an error if it does not.
    */
@@ skipping 101 matching lines @@
       Source librarySource, this.kind, this.currentResult) {
     _newSources.add(librarySource);
   }
 
   @override
   void set currentValue(Object value) {
     LibraryElement library = value;
     if (_libraries.add(library)) {
       if (kind == _SourceClosureKind.IMPORT ||
           kind == _SourceClosureKind.IMPORT_EXPORT) {
-        for (ImportElement importElement in library.imports) {
+        List<ImportElement> imports = library.imports;
+        int length = imports.length;
+        for (int i = 0; i < length; i++) {
+          ImportElement importElement = imports[i];
           Source importedSource = importElement.importedLibrary.source;
           _newSources.add(importedSource);
         }
       }
       if (kind == _SourceClosureKind.EXPORT ||
           kind == _SourceClosureKind.IMPORT_EXPORT) {
-        for (ExportElement exportElement in library.exports) {
+        List<ExportElement> exports = library.exports;
+        int length = exports.length;
+        for (int i = 0; i < length; i++) {
+          ExportElement exportElement = exports[i];
           Source exportedSource = exportElement.exportedLibrary.source;
           _newSources.add(exportedSource);
         }
       }
     }
   }
 
   @override
   bool get flushOnAccess => false;
 
@@ skipping 10 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }