Convert some for-in loops for performance

pkg/analyzer/lib/src/generated/resolver.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.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 1042 matching lines @@
  */
 class BuildLibraryElementUtils {
   /**
    * Look through all of the compilation units defined for the given [library],
    * looking for getters and setters that are defined in different compilation
    * units but that have the same names. If any are found, make sure that they
    * have the same variable element.
    */
   static void patchTopLevelAccessors(LibraryElementImpl library) {
     // Without parts getters/setters already share the same variable element.
-    if (library.parts.isEmpty) {
+    List<CompilationUnitElement> parts = library.parts;
+    if (parts.isEmpty) {
       return;
     }
     // Collect getters and setters.
     HashMap<String, PropertyAccessorElement> getters =
         new HashMap<String, PropertyAccessorElement>();
     List<PropertyAccessorElement> setters = <PropertyAccessorElement>[];
     _collectAccessors(getters, setters, library.definingCompilationUnit);
-    for (CompilationUnitElement unit in library.parts) {
+    int partLength = parts.length;
+    for (int i = 0; i < partLength; i++) {
+      CompilationUnitElement unit = parts[i];
       _collectAccessors(getters, setters, unit);
     }
     // Move every setter to the corresponding getter's variable (if exists).
-    for (PropertyAccessorElement setter in setters) {
+    int setterLength = setters.length;
+    for (int j = 0; j < setterLength; j++) {
+      PropertyAccessorElement setter = setters[j];
       PropertyAccessorElement getter = getters[setter.displayName];
       if (getter != null) {
         TopLevelVariableElementImpl variable = getter.variable;
         TopLevelVariableElementImpl setterVariable = setter.variable;
         CompilationUnitElementImpl setterUnit = setterVariable.enclosingElement;
         setterUnit.replaceTopLevelVariable(setterVariable, variable);
         variable.setter = setter;
         (setter as PropertyAccessorElementImpl).variable = variable;
       }
     }
   }
 
   /**
    * Add all of the non-synthetic [getters] and [setters] defined in the given
    * [unit] that have no corresponding accessor to one of the given collections.
    */
   static void _collectAccessors(Map<String, PropertyAccessorElement> getters,
       List<PropertyAccessorElement> setters, CompilationUnitElement unit) {
-    for (PropertyAccessorElement accessor in unit.accessors) {
+    List<PropertyAccessorElement> accessors = unit.accessors;
+    int length = accessors.length;
+    for (int i = 0; i < length; i++) {
+      PropertyAccessorElement accessor = accessors[i];
       if (accessor.isGetter) {
         if (!accessor.isSynthetic && accessor.correspondingSetter == null) {
           getters[accessor.displayName] = accessor;
         }
       } else {
         if (!accessor.isSynthetic && accessor.correspondingGetter == null) {
           setters.add(accessor);
         }
       }
     }
@@ skipping 204 matching lines @@
             invalidKeys.add(key);
           } else {
             keys.add(result);
           }
         } else {
           reportEqualKeys = false;
         }
       }
     }
     if (reportEqualKeys) {
-      for (Expression key in invalidKeys) {
+      int length = invalidKeys.length;
+      for (int i = 0; i < length; i++) {
         _errorReporter.reportErrorForNode(
-            StaticWarningCode.EQUAL_KEYS_IN_MAP, key);
+            StaticWarningCode.EQUAL_KEYS_IN_MAP, invalidKeys[i]);
       }
     }
     return null;
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
     _validateDefaultValues(node.parameters);
     return null;
@@ skipping 131 matching lines @@
   }
 
   /**
    * Report any errors in the given list. Except for special cases, use the given error code rather
    * than the one reported in the error.
    *
    * @param errors the errors that need to be reported
    * @param errorCode the error code to be used
    */
   void _reportErrors(List<AnalysisError> errors, ErrorCode errorCode) {
-    for (AnalysisError data in errors) {
+    int length = errors.length;
+    for (int i = 0; i < length; i++) {
+      AnalysisError data = errors[i];
       ErrorCode dataErrorCode = data.errorCode;
       if (identical(dataErrorCode,
               CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION) ||
           identical(
               dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE) ||
           identical(dataErrorCode,
               CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_INT) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM) ||
@@ skipping 489 matching lines @@
               // this catch clause is not the last in the try statement
               CatchClause nextCatchClause = catchClauses[i + 1];
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = nextCatchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportErrorForOffset(
                   HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length);
               return null;
             }
           }
-          for (DartType type in visitedTypes) {
+          int length = visitedTypes.length;
+          for (int j = 0; j < length; j++) {
+            DartType type = visitedTypes[j];
             if (_typeSystem.isSubtypeOf(currentType, type)) {
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = catchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportErrorForOffset(
                   HintCode.DEAD_CODE_ON_CATCH_SUBTYPE,
                   offset,
                   length,
                   [currentType.displayName, type.displayName]);
               return null;
@@ skipping 683 matching lines @@
 
   /**
    * Return the element in the given list of [elements] that was created for the
    * declaration with the given [name] at the given [offset]. Throw an
    * [ElementMismatchException] if an element corresponding to the identifier
    * cannot be found unless [required] is `false`, in which case return `null`.
    */
   Element _findWithNameAndOffset(
       List<Element> elements, AstNode node, String name, int offset,
       {bool required: true}) {
-    for (Element element in elements) {
+    int length = elements.length;
+    for (int i = 0; i < length; i++) {
+      Element element = elements[i];
       if (element.nameOffset == offset && element.name == name) {
         return element;
       }
     }
     if (!required) {
       return null;
     }
-    for (Element element in elements) {
+    for (int i = 0; i < length; i++) {
+      Element element = elements[i];
       if (element.name == name) {
         _mismatch(
             'Found element with name "$name" at ${element.nameOffset}, '
             'but expected offset of $offset',
             node);
       }
       if (element.nameOffset == offset) {
         _mismatch(
             'Found element with name "${element.name}" at $offset, '
             'but expected element with name "$name"',
@@ skipping 140 matching lines @@
   /**
    * Return the export element from the given list of [exports] whose library
    * has the given [source]. Throw an [ElementMismatchException] if an element
    * corresponding to the identifier cannot be found.
    */
   ExportElement _findExport(
       ExportDirective node, List<ExportElement> exports, Source source) {
     if (source == null) {
       return null;
     }
-    for (ExportElement export in exports) {
+    int length = exports.length;
+    for (int i = 0; i < length; i++) {
+      ExportElement export = exports[i];
       if (export.exportedLibrary.source == source) {
         // Must have the same offset.
         if (export.nameOffset != node.offset) {
           continue;
         }
         // In general we should also match combinators.
         // But currently we invalidate element model on any directive change.
         // So, either the combinators are the same, or we build new elements.
         return export;
       }
@@ skipping 10 matching lines @@
    * has the given [source]. Throw an [ElementMismatchException] if an element
    * corresponding to the [source] cannot be found.
    */
   ImportElement _findImport(
       ImportDirective node, List<ImportElement> imports, Source source) {
     if (source == null) {
       return null;
     }
     SimpleIdentifier prefix = node.prefix;
     bool foundSource = false;
-    for (ImportElement element in imports) {
+    int length = imports.length;
+    for (int i = 0; i < length; i++) {
+      ImportElement element = imports[i];
       if (element.importedLibrary.source == source) {
         foundSource = true;
         // Must have the same offset.
         if (element.nameOffset != node.offset) {
           continue;
         }
         // Must have the same prefix.
         if (element.prefix?.displayName != prefix?.name) {
           continue;
         }
@@ skipping 275 matching lines @@
     if (_typeParameters == null) {
       _typeParameters = new List<TypeParameterElement>();
     }
     _typeParameters.add(element);
   }
 
   FieldElement getField(String fieldName) {
     if (_fields == null) {
       return null;
     }
-    for (FieldElement field in _fields) {
+    int length = _fields.length;
+    for (int i = 0; i < length; i++) {
+      FieldElement field = _fields[i];
       if (field.name == fieldName) {
         return field;
       }
     }
     return null;
   }
 
   TopLevelVariableElement getTopLevelVariable(String variableName) {
     if (_topLevelVariables == null) {
       return null;
     }
-    for (TopLevelVariableElement variable in _topLevelVariables) {
+    int length = _topLevelVariables.length;
+    for (int i = 0; i < length; i++) {
+      TopLevelVariableElement variable = _topLevelVariables[i];
       if (variable.name == variableName) {
         return variable;
       }
     }
     return null;
   }
 
   void validate() {
     StringBuffer buffer = new StringBuffer();
     if (_accessors != null) {
@@ skipping 767 matching lines @@
     directive.metadata.accept(this);
   }
 
   void _visitIdentifier(SimpleIdentifier identifier, Element element) {
     if (element == null) {
       return;
     }
     // If the element is multiply defined then call this method recursively for
     // each of the conflicting elements.
     if (element is MultiplyDefinedElement) {
-      for (Element elt in element.conflictingElements) {
+      List<Element> conflictingElements = element.conflictingElements;
+      int length = conflictingElements.length;
+      for (int i = 0; i < length; i++) {
+        Element elt = conflictingElements[i];
         _visitIdentifier(identifier, elt);
       }
       return;
     }
 
     // Record `importPrefix.identifier` into 'prefixMap'.
     if (_recordPrefixMap(identifier, element)) {
       return;
     }
 
@@ skipping 205 matching lines @@
     _library = _compilationUnits[0].element.library;
     _usedImportedElementsVisitor =
         new GatherUsedImportedElementsVisitor(_library);
     _enableDart2JSHints = _context.analysisOptions.dart2jsHint;
     _manager = new InheritanceManager(_library);
     _usedLocalElementsVisitor = new GatherUsedLocalElementsVisitor(_library);
   }
 
   void generateForLibrary() {
     PerformanceStatistics.hints.makeCurrentWhile(() {
-      for (CompilationUnit unit in _compilationUnits) {
+      int length = _compilationUnits.length;
+      for (int i = 0; i < length; i++) {
+        CompilationUnit unit = _compilationUnits[i];
         CompilationUnitElement element = unit.element;
         if (element != null) {
           _generateForCompilationUnit(unit, element.source);
         }
       }
       CompilationUnit definingUnit = _compilationUnits[0];
       ErrorReporter definingUnitErrorReporter =
           new ErrorReporter(_errorListener, definingUnit.element.source);
       {
         ImportsVerifier importsVerifier = new ImportsVerifier();
@@ skipping 180 matching lines @@
 
   /**
    * Any time after the defining compilation unit has been visited by this visitor, this method can
    * be called to report an [HintCode.DUPLICATE_IMPORT] hint for each of the import directives
    * in the [duplicateImports] list.
    *
    * @param errorReporter the error reporter to report the set of [HintCode.DUPLICATE_IMPORT]
    *          hints to
    */
   void generateDuplicateImportHints(ErrorReporter errorReporter) {
-    for (ImportDirective duplicateImport in _duplicateImports) {
+    int length = _duplicateImports.length;
+    for (int i = 0; i < length; i++) {
       errorReporter.reportErrorForNode(
-          HintCode.DUPLICATE_IMPORT, duplicateImport.uri);
+          HintCode.DUPLICATE_IMPORT, _duplicateImports[i].uri);
     }
   }
 
   /**
    * Report an [HintCode.UNUSED_IMPORT] hint for each unused import.
    *
    * Only call this method after all of the compilation units have been visited by this visitor.
    *
    * @param errorReporter the error reporter used to report the set of [HintCode.UNUSED_IMPORT]
    *          hints
    */
   void generateUnusedImportHints(ErrorReporter errorReporter) {
-    for (ImportDirective unusedImport in _unusedImports) {
+    int length = _unusedImports.length;
+    for (int i = 0; i < length; i++) {
+      ImportDirective unusedImport = _unusedImports[i];
       // Check that the import isn't dart:core
       ImportElement importElement = unusedImport.element;
       if (importElement != null) {
         LibraryElement libraryElement = importElement.importedLibrary;
         if (libraryElement != null && libraryElement.isDartCore) {
           continue;
         }
       }
       errorReporter.reportErrorForNode(
           HintCode.UNUSED_IMPORT, unusedImport.uri);
     }
   }
 
   /**
    * Report an [HintCode.UNUSED_SHOWN_NAME] hint for each unused shown name.
    *
    * Only call this method after all of the compilation units have been visited by this visitor.
    *
    * @param errorReporter the error reporter used to report the set of [HintCode.UNUSED_SHOWN_NAME]
    *          hints
    */
   void generateUnusedShownNameHints(ErrorReporter reporter) {
     _unusedShownNamesMap.forEach(
         (ImportDirective importDirective, List<SimpleIdentifier> identifiers) {
       if (_unusedImports.contains(importDirective)) {
         // This import is actually wholly unused, not just one or more shown names from it.
         // This is then an "unused import", rather than unused shown names.
         return;
       }
-      for (Identifier identifier in identifiers) {
+      int length = identifiers.length;
+      for (int i = 0; i < length; i++) {
+        Identifier identifier = identifiers[i];
         reporter.reportErrorForNode(
             HintCode.UNUSED_SHOWN_NAME, identifier, [identifier.name]);
       }
     });
   }
 
   /**
    * Remove elements from [_unusedImports] using the given [usedElements].
    */
   void removeUsedElements(UsedImportedElements usedElements) {
     // Stop if all the imports and shown names are known to be used.
     if (_unusedImports.isEmpty && _unusedShownNamesMap.isEmpty) {
       return;
     }
     // Process import prefixes.
     usedElements.prefixMap
         .forEach((PrefixElement prefix, List<Element> elements) {
       List<ImportDirective> importDirectives = _prefixElementMap[prefix];
       if (importDirectives != null) {
-        for (ImportDirective importDirective in importDirectives) {
+        int importLength = importDirectives.length;
+        for (int i = 0; i < importLength; i++) {
+          ImportDirective importDirective = importDirectives[i];
           _unusedImports.remove(importDirective);
-          for (Element element in elements) {
+          int elementLength = elements.length;
+          for (int j = 0; j < elementLength; j++) {
+            Element element = elements[j];
             _removeFromUnusedShownNamesMap(element, importDirective);
           }
         }
       }
     });
     // Process top-level elements.
     for (Element element in usedElements.elements) {
       // Stop if all the imports and shown names are known to be used.
       if (_unusedImports.isEmpty && _unusedShownNamesMap.isEmpty) {
         return;
@@ skipping 27 matching lines @@
   }
 
   /**
    * Recursively add any exported library elements into the [libraryMap].
    */
   void _addAdditionalLibrariesForExports(LibraryElement library,
       ImportDirective importDirective, Set<LibraryElement> visitedLibraries) {
     if (!visitedLibraries.add(library)) {
       return;
     }
-    for (ExportElement exportElt in library.exports) {
+    List<ExportElement> exports = library.exports;
+    int length = exports.length;
+    for (int i = 0; i < length; i++) {
+      ExportElement exportElt = exports[i];
       LibraryElement exportedLibrary = exportElt.exportedLibrary;
       _putIntoLibraryMap(exportedLibrary, importDirective);
       _addAdditionalLibrariesForExports(
           exportedLibrary, importDirective, visitedLibraries);
     }
   }
 
   /**
    * Add every shown name from [importDirective] into [_unusedShownNamesMap].
    */
@@ skipping 54 matching lines @@
 
   /**
    * Remove [element] from the list of names shown by [importDirective].
    */
   void _removeFromUnusedShownNamesMap(
       Element element, ImportDirective importDirective) {
     List<SimpleIdentifier> identifiers = _unusedShownNamesMap[importDirective];
     if (identifiers == null) {
       return;
     }
-    for (Identifier identifier in identifiers) {
+    int length = identifiers.length;
+    for (int i = 0; i < length; i++) {
+      Identifier identifier = identifiers[i];
       if (element is PropertyAccessorElement) {
         // If the getter or setter of a variable is used, then the variable (the
         // shown name) is used.
         if (identifier.staticElement == element.variable) {
           identifiers.remove(identifier);
           break;
         }
       } else {
         if (identifier.staticElement == element) {
           identifiers.remove(identifier);
@@ skipping 203 matching lines @@
         visited = new HashSet<Element>();
       }
       if (element == null || !visited.add(element)) {
         return false;
       }
       try {
         if (match(t1.superclass, visited)) {
           return true;
         }
 
-        for (final parent in t1.mixins) {
-          if (match(parent, visited)) {
+        List<InterfaceType> mixins = t1.mixins;
+        int mixinLength = mixins.length;
+        for (int i = 0; i < mixinLength; i++) {
+          if (match(mixins[i], visited)) {
             return true;
           }
         }
 
-        for (final parent in t1.interfaces) {
-          if (match(parent, visited)) {
+        List<InterfaceType> interfaces = t1.interfaces;
+        int interfaceLength = interfaces.length;
+        for (int j = 0; j < interfaceLength; j++) {
+          if (match(interfaces[j], visited)) {
             return true;
           }
         }
       } finally {
         visited.remove(element);
       }
       return false;
     }
 
     // We have that t1 = T1<dynamic, ..., dynamic>.
@@ skipping 316 matching lines @@
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _addPropagableVariables(node.variables.variables);
     _addStaticVariables(node.variables.variables);
     return super.visitTopLevelVariableDeclaration(node);
   }
 
   /**
    * Add all of the [variables] with initializers to [propagableVariables].
    */
   void _addPropagableVariables(List<VariableDeclaration> variables) {
-    for (VariableDeclaration variable in variables) {
+    int length = variables.length;
+    for (int i = 0; i < length; i++) {
+      VariableDeclaration variable = variables[i];
       if (variable.name.name.isNotEmpty && variable.initializer != null) {
         VariableElement element = variable.element;
         if (element.isConst || element.isFinal) {
           propagableVariables.add(element);
         }
       }
     }
   }
 
   /**
    * Add all of the [variables] with initializers to the list of variables whose
    * type can be inferred. Technically, we only infer the types of variables
    * that do not have a static type, but all variables with initializers
    * potentially need to be re-resolved after inference because they might
    * refer to a field whose type was inferred.
    */
   void _addStaticVariables(List<VariableDeclaration> variables) {
-    for (VariableDeclaration variable in variables) {
+    int length = variables.length;
+    for (int i = 0; i < length; i++) {
+      VariableDeclaration variable = variables[i];
       if (variable.name.name.isNotEmpty && variable.initializer != null) {
         staticVariables.add(variable.element);
       }
     }
   }
 
   /**
    * Return `true` if the given function body should be skipped because it is
    * the body of a top-level function, method or constructor.
    */
@@ skipping 2191 matching lines @@
       List<ParameterElement> parameters,
       void onError(ErrorCode errorCode, AstNode node, [List<Object> arguments]),
       {bool reportAsError: false}) {
     if (parameters.isEmpty && argumentList.arguments.isEmpty) {
       return const <ParameterElement>[];
     }
     int requiredParameterCount = 0;
     int unnamedParameterCount = 0;
     List<ParameterElement> unnamedParameters = new List<ParameterElement>();
     HashMap<String, ParameterElement> namedParameters = null;
-    for (ParameterElement parameter in parameters) {
+    int length = parameters.length;
+    for (int i = 0; i < length; i++) {
+      ParameterElement parameter = parameters[i];
       ParameterKind kind = parameter.parameterKind;
       if (kind == ParameterKind.REQUIRED) {
         unnamedParameters.add(parameter);
         unnamedParameterCount++;
         requiredParameterCount++;
       } else if (kind == ParameterKind.POSITIONAL) {
         unnamedParameters.add(parameter);
         unnamedParameterCount++;
       } else {
         namedParameters ??= new HashMap<String, ParameterElement>();
@@ skipping 526 matching lines @@
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     Scope outerScope = nameScope;
     try {
       ParameterElement parameterElement = node.element;
       if (parameterElement == null) {
         AnalysisEngine.instance.logger.logInformation(
             "Missing element for function typed formal parameter ${node.identifier.name} in ${definingLibrary.source.fullName}",
             new CaughtException(new AnalysisException(), null));
       } else {
         nameScope = new EnclosedScope(nameScope);
-        for (TypeParameterElement typeParameter
-            in parameterElement.typeParameters) {
-          nameScope.define(typeParameter);
+        List<TypeParameterElement> typeParameters =
+            parameterElement.typeParameters;
+        int length = typeParameters.length;
+        for (int i = 0; i < length; i++) {
+          nameScope.define(typeParameters[i]);
         }
       }
       super.visitFunctionTypedFormalParameter(node);
     } finally {
       nameScope = outerScope;
     }
     return null;
   }
 
   @override
@@ skipping 225 matching lines @@
    */
   void _computeSubtypesInClass(ClassElement classElement) {
     InterfaceType supertypeType = classElement.supertype;
     if (supertypeType != null) {
       ClassElement supertypeElement = supertypeType.element;
       if (supertypeElement != null) {
         _putInSubtypeMap(supertypeElement, classElement);
       }
     }
     List<InterfaceType> interfaceTypes = classElement.interfaces;
-    for (InterfaceType interfaceType in interfaceTypes) {
+    int interfaceLength = interfaceTypes.length;
+    for (int i = 0; i < interfaceLength; i++) {
+      InterfaceType interfaceType = interfaceTypes[i];
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
         _putInSubtypeMap(interfaceElement, classElement);
       }
     }
     List<InterfaceType> mixinTypes = classElement.mixins;
-    for (InterfaceType mixinType in mixinTypes) {
+    int mixinLength = mixinTypes.length;
+    for (int i = 0; i < mixinLength; i++) {
+      InterfaceType mixinType = mixinTypes[i];
       ClassElement mixinElement = mixinType.element;
       if (mixinElement != null) {
         _putInSubtypeMap(mixinElement, classElement);
       }
     }
   }
 
   /**
    * Given some [CompilationUnitElement], this method calls
    * [computeAllSubtypes] on all of the [ClassElement]s in the
    * compilation unit.
    *
    * @param unitElement the compilation unit element
    */
   void _computeSubtypesInCompilationUnit(CompilationUnitElement unitElement) {
     List<ClassElement> classElements = unitElement.types;
-    for (ClassElement classElement in classElements) {
+    int length = classElements.length;
+    for (int i = 0; i < length; i++) {
+      ClassElement classElement = classElements[i];
       _computeSubtypesInClass(classElement);
     }
   }
 
   /**
    * Given some [LibraryElement], this method calls
    * [computeAllSubtypes] on all of the [ClassElement]s in the
    * compilation unit, and itself for all imported and exported libraries. All visited libraries are
    * added to the [visitedLibraries] set.
    *
    * @param libraryElement the library element
    */
   void _computeSubtypesInLibrary(LibraryElement libraryElement) {
     if (libraryElement == null || _visitedLibraries.contains(libraryElement)) {
       return;
     }
     _visitedLibraries.add(libraryElement);
     _computeSubtypesInCompilationUnit(libraryElement.definingCompilationUnit);
     List<CompilationUnitElement> parts = libraryElement.parts;
-    for (CompilationUnitElement part in parts) {
+    int partLength = parts.length;
+    for (int i = 0; i < partLength; i++) {
+      CompilationUnitElement part = parts[i];
       _computeSubtypesInCompilationUnit(part);
     }
     List<LibraryElement> imports = libraryElement.importedLibraries;
-    for (LibraryElement importElt in imports) {
+    int importLength = imports.length;
+    for (int i = 0; i < importLength; i++) {
+      LibraryElement importElt = imports[i];
       _computeSubtypesInLibrary(importElt.library);
     }
     List<LibraryElement> exports = libraryElement.exportedLibraries;
-    for (LibraryElement exportElt in exports) {
+    int exportLength = exports.length;
+    for (int i = 0; i < exportLength; i++) {
+      LibraryElement exportElt = exports[i];
       _computeSubtypesInLibrary(exportElt.library);
     }
   }
 
   /**
    * Add some key/ value pair into the [subtypeMap] map.
    *
    * @param supertypeElement the key for the [subtypeMap] map
    * @param subtypeElement the value for the [subtypeMap] map
    */
@@ skipping 462 matching lines @@
 
   /**
    * Given the multiple elements to which a single name could potentially be resolved, return the
    * single interface type that should be used, or `null` if there is no clear choice.
    *
    * @param elements the elements to which a single name could potentially be resolved
    * @return the single interface type that should be used for the type name
    */
   InterfaceType _getTypeWhenMultiplyDefined(List<Element> elements) {
     InterfaceType type = null;
-    for (Element element in elements) {
+    int length = elements.length;
+    for (int i = 0; i < length; i++) {
+      Element element = elements[i];
       if (element is ClassElement) {
         if (type != null) {
           return null;
         }
         type = element.type;
       }
     }
     return type;
   }
 
@@ skipping 201 matching lines @@
   }
 
   /**
    * Update overrides assuming [perBranchOverrides] is the collection of
    * per-branch overrides for *all* branches flowing into a join point.
    *
    * If a variable type in any of branches is not the same as its type before
    * the branching, then its propagated type is reset to `null`.
    */
   void mergeOverrides(List<Map<VariableElement, DartType>> perBranchOverrides) {
-    for (Map<VariableElement, DartType> branch in perBranchOverrides) {
+    int length = perBranchOverrides.length;
+    for (int i = 0; i < length; i++) {
+      Map<VariableElement, DartType> branch = perBranchOverrides[i];
       branch.forEach((VariableElement variable, DartType branchType) {
         DartType currentType = currentScope.getType(variable);
         if (currentType != branchType) {
           currentScope.resetType(variable);
         }
       });
     }
   }
 
   /**
@@ skipping 1601 matching lines @@
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 
   UsedLocalElements();
 
   factory UsedLocalElements.merge(List<UsedLocalElements> parts) {
     UsedLocalElements result = new UsedLocalElements();
-    for (UsedLocalElements part in parts) {
+    int length = parts.length;
+    for (int i = 0; i < length; i++) {
+      UsedLocalElements part = parts[i];
       result.elements.addAll(part.elements);
       result.catchExceptionElements.addAll(part.catchExceptionElements);
       result.catchStackTraceElements.addAll(part.catchStackTraceElements);
       result.members.addAll(part.members);
       result.readMembers.addAll(part.readMembers);
     }
     return result;
   }
 
   void addCatchException(LocalVariableElement element) {
@@ skipping 218 matching lines @@
       {TypeSystem typeSystem})
       : _typeSystem = typeSystem ?? new TypeSystemImpl(),
         super(
             new ConstantEvaluationEngine(typeProvider, declaredVariables,
                 typeSystem: typeSystem),
             errorReporter);
 
   @override
   DartObjectImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
-    for (ParameterElement parameterElement in parameterElements) {
+    int length = parameterElements.length;
+    for (int i = 0; i < length; i++) {
+      ParameterElement parameterElement = parameterElements[i];
       if (identical(parameterElement, element) && parameterElement != null) {
         DartType type = parameterElement.type;
         if (type != null) {
           if (type.isDynamic) {
             return new DartObjectImpl(
                 verifier._typeProvider.objectType, DynamicState.DYNAMIC_STATE);
           } else if (_typeSystem.isSubtypeOf(type, verifier._boolType)) {
             return new DartObjectImpl(
                 verifier._typeProvider.boolType, BoolState.UNKNOWN_VALUE);
           } else if (_typeSystem.isSubtypeOf(
@@ skipping 74 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }