Remove references to and uses of MemberMap

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 analyzer.src.generated.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 3637 matching lines @@
   /**
    * For each class declaration, this method is called which verifies that all
    * inherited members are inherited consistently.
    *
    * See [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE].
    */
   void _checkForInconsistentMethodInheritance() {
     // Ensure that the inheritance manager has a chance to generate all errors
     // we may care about, note that we ensure that the interfaces data since
     // there are no errors.
-    _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
-    HashSet<AnalysisError> errors =
-        _inheritanceManager.getErrors(_enclosingClass);
+    _inheritanceManager.getMembersInheritedFromInterfaces(_enclosingClass);
+    Set<AnalysisError> errors = _inheritanceManager.getErrors(_enclosingClass);
     if (errors == null || errors.isEmpty) {
       return;
     }
     for (AnalysisError error in errors) {
       _errorReporter.reportError(error);
     }
     return;
   }
 
   /**
@@ skipping 848 matching lines @@
     }
     //
     // Store in local sets the set of all method and accessor names
     //
     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 = _inheritanceManager
-        .getMapOfMembersInheritedFromClasses(_enclosingClass);
-    for (int i = 0; i < membersInheritedFromInterfaces.size; i++) {
-      String memberName = membersInheritedFromInterfaces.getKey(i);
+    Map<String, ExecutableElement> membersInheritedFromInterfaces =
+        _inheritanceManager.getMembersInheritedFromInterfaces(_enclosingClass);
+    Map<String, ExecutableElement> membersInheritedFromSuperclasses =
+        _inheritanceManager.getMembersInheritedFromClasses(_enclosingClass);
+    for (String memberName in membersInheritedFromInterfaces.keys) {
       ExecutableElement executableElt =
-          membersInheritedFromInterfaces.getValue(i);
+          membersInheritedFromInterfaces[memberName];
       if (memberName == null) {
         break;
       }
       // If the element is not synthetic and can be determined to be defined in
       // Object, skip it.
       if (executableElt.enclosingElement != null &&
           (executableElt.enclosingElement as ClassElement).type.isObject) {
         continue;
       }
       // Check to see if some element is in local enclosing class that matches
       // the name of the required member.
       if (_isMemberInClassOrMixin(executableElt, _enclosingClass)) {
         // We do not have to verify that this implementation of the found method
         // matches the required function type: the set of
         // StaticWarningCode.INVALID_METHOD_OVERRIDE_* warnings break out the
         // different specific situations.
         continue;
       }
       // First check to see if this element was declared in the superclass
       // chain, in which case there is already a concrete implementation.
-      ExecutableElement elt = membersInheritedFromSuperclasses.get(memberName);
+      ExecutableElement elt = membersInheritedFromSuperclasses[memberName];
       // Check to see if an element was found in the superclass chain with the
       // correct name.
       if (elt != null) {
         // Reference the types, if any are null then continue.
         InterfaceType enclosingType = _enclosingClass.type;
         FunctionType concreteType = elt.type;
         FunctionType requiredMemberType = executableElt.type;
         if (enclosingType == null ||
             concreteType == null ||
             requiredMemberType == null) {
@@ skipping 1595 matching lines @@
 class _InvocationCollector extends RecursiveAstVisitor {
   final List<String> superCalls = <String>[];
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.target is SuperExpression) {
       superCalls.add(node.methodName.name);
     }
   }
 }