Use direct lookup rather than iteration

pkg/analyzer/lib/src/generated/error_verifier.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 engine.resolver.error_verifier;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
@@ skipping 3795 matching lines @@
       InterfaceType superclassType = _enclosingClass.supertype;
       ClassElement superclassElement =
           superclassType == null ? null : superclassType.element;
       bool executableElementPrivate =
           Identifier.isPrivateName(executableElementName);
       while (superclassElement != null &&
           !visitedClasses.contains(superclassElement)) {
         visitedClasses.add(superclassElement);
         LibraryElement superclassLibrary = superclassElement.library;
         // Check fields.
-        List<FieldElement> fieldElts = superclassElement.fields;
-        for (FieldElement fieldElt in fieldElts) {
-          // We need the same name.
-          if (fieldElt.name != executableElementName) {
-            continue;
-          }
+        FieldElement fieldElt = superclassElement.getField(executableElementName);
+        if (fieldElt != null) {
           // Ignore if private in a different library - cannot collide.
           if (executableElementPrivate &&
               _currentLibrary != superclassLibrary) {
             continue;
           }
           // instance vs. static
           if (fieldElt.isStatic) {
             _errorReporter.reportErrorForNode(
                 StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC,
                 errorNameTarget,
@@ skipping 748 matching lines @@
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS].
    */
   bool
       _checkForNonAbstractClassInheritsAbstractMember(SimpleIdentifier classNameNode) {
     if (_enclosingClass.isAbstract) {
       return false;
     }
     //
     // Store in local sets the set of all method and accessor names
     //
-    List<MethodElement> methods = _enclosingClass.methods;
-    for (MethodElement method in methods) {
-      String methodName = method.name;
+    MethodElement method =
+        _enclosingClass.getMethod(FunctionElement.NO_SUCH_METHOD_METHOD_NAME);
+    if (method != null) {
       // If the enclosing class declares the method noSuchMethod(), then return.
       // From Spec:  It is a static warning if a concrete class does not have an
       // implementation for a method in any of its superinterfaces unless it
       // declares its own noSuchMethod method (7.10).
-      if (methodName == FunctionElement.NO_SUCH_METHOD_METHOD_NAME) {
-        return false;
-      }
+      return false;
     }
     HashSet<ExecutableElement> missingOverrides =
         new HashSet<ExecutableElement>();
     //
     // Loop through the set of all executable elements declared in the implicit
     // interface.
     //
     MemberMap membersInheritedFromInterfaces =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
     MemberMap membersInheritedFromSuperclasses =
@@ skipping 1720 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }