Optimize more megamorphic dispatch sites

pkg/analyzer/lib/src/dart/resolver/scope.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.resolver.scope;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 39 matching lines @@
             [existing.displayName]);
       }
     }
     return super.getErrorForDuplicate(existing, duplicate);
   }
 
   /**
    * Define the instance members defined by the given [classElement].
    */
   void _defineMembers(ClassElement classElement) {
-    for (PropertyAccessorElement accessor in classElement.accessors) {
-      define(accessor);
+    List<PropertyAccessorElement> accessors = classElement.accessors;
+    int accessorLength = accessors.length;
+    for (int i = 0; i < accessorLength; i++) {
+      define(accessors[i]);
     }
-    for (MethodElement method in classElement.methods) {
-      define(method);
+    List<MethodElement> methods = classElement.methods;
+    int methodLength = methods.length;
+    for (int i = 0; i < methodLength; i++) {
+      define(methods[i]);
     }
   }
 }
 
 /**
  * A scope that is lexically enclosed in another scope.
  */
 class EnclosedScope extends Scope {
   /**
    * The scope in which this scope is lexically enclosed.
@@ skipping 92 matching lines @@
   /**
    * Define the parameters for the given function in the scope that encloses
    * this function.
    */
   void defineParameters() {
     if (_parametersDefined) {
       return;
     }
     _parametersDefined = true;
     Scope parameterScope = enclosingScope;
-    for (ParameterElement parameter in _functionElement.parameters) {
+    List<ParameterElement> parameters = _functionElement.parameters;
+    int length = parameters.length;
+    for (int i = 0; i < length; i++) {
+      ParameterElement parameter = parameters[i];
       if (!parameter.isInitializingFormal) {
         parameterScope.define(parameter);
       }
     }
   }
 
   /**
    * Define the type parameters for the function.
    */
   void _defineTypeParameters() {
     Scope typeParameterScope = enclosingScope.enclosingScope;
-    for (TypeParameterElement typeParameter
-        in _functionElement.typeParameters) {
+    List<TypeParameterElement> typeParameters = _functionElement.typeParameters;
+    int length = typeParameters.length;
+    for (int i = 0; i < length; i++) {
+      TypeParameterElement typeParameter = typeParameters[i];
       typeParameterScope.define(typeParameter);
     }
   }
 }
 
 /**
  * The scope defined by a function type alias.
  */
 class FunctionTypeScope extends EnclosedScope {
   final FunctionTypeAliasElement _typeElement;
@@ skipping 999 matching lines @@
 
   /**
    * Define the type parameters declared by the [classElement].
    */
   void _defineTypeParameters(ClassElement classElement) {
     for (TypeParameterElement typeParameter in classElement.typeParameters) {
       define(typeParameter);
     }
   }
 }