Remove references to and uses of MemberMap

pkg/analyzer/test/generated/inheritance_manager_test.dart

 // Copyright (c) 2016, 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.test.generated.inheritance_manager_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 51 matching lines @@
 
   void test_getMapOfMembersInheritedFromClasses_accessor_extends() {
     // class A { int get g; }
     // class B extends A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG =
         ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement>[getterG];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject + 1);
-    expect(mapB.get(getterName), same(getterG));
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromClasses(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromClasses(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject + 1);
+    expect(mapB[getterName], same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_accessor_implements() {
     // class A { int get g; }
     // class B implements A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG =
         ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement>[getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType>[classA.type];
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject);
-    expect(mapB.get(getterName), isNull);
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromClasses(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromClasses(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject);
+    expect(mapB[getterName], isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_accessor_with() {
     // class A { int get g; }
     // class B extends Object with A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG =
         ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement>[getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType>[classA.type];
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject + 1);
-    expect(mapB.get(getterName), same(getterG));
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromClasses(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromClasses(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject + 1);
+    expect(mapB[getterName], same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_implicitExtends() {
     // class A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    expect(mapA.size, _numOfMembersInObject);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromClasses(classA);
+    expect(mapA.length, _numOfMembersInObject);
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromClasses_method_extends() {
     // class A { int g(); }
     // class B extends A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
     MethodElement methodM =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement>[methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.supertype = classA.type;
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject + 1);
-    expect(mapB.get(methodName), same(methodM));
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromClasses(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromClasses(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject + 1);
+    expect(mapB[methodName], same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_method_implements() {
     // class A { int g(); }
     // class B implements A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
     MethodElement methodM =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement>[methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType>[classA.type];
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject);
-    expect(mapB.get(methodName), isNull);
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromClasses(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromClasses(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject);
+    expect(mapB[methodName], isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_method_with() {
     // class A { int g(); }
     // class B extends Object with A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
     MethodElement methodM =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement>[methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType>[classA.type];
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject + 1);
-    expect(mapB.get(methodName), same(methodM));
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromClasses(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromClasses(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject + 1);
+    expect(mapB[methodName], same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_method_with_two_mixins() {
     // class A1 { int m(); }
     // class A2 { int m(); }
     // class B extends Object with A1, A2 {}
     ClassElementImpl classA1 = ElementFactory.classElement2("A1");
     String methodName = "m";
     MethodElement methodA1M =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA1.methods = <MethodElement>[methodA1M];
     ClassElementImpl classA2 = ElementFactory.classElement2("A2");
     MethodElement methodA2M =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA2.methods = <MethodElement>[methodA2M];
     ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType>[classA1.type, classA2.type];
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    expect(mapB.get(methodName), same(methodA2M));
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromClasses(classB);
+    expect(mapB[methodName], same(methodA2M));
     _assertNoErrors(classA1);
     _assertNoErrors(classA2);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_accessor_extends() {
     // class A { int get g; }
     // class B extends A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG =
         ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement>[getterG];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject + 1);
-    expect(mapB.get(getterName), same(getterG));
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject + 1);
+    expect(mapB[getterName], same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_accessor_implements() {
     // class A { int get g; }
     // class B implements A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG =
         ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement>[getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType>[classA.type];
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject + 1);
-    expect(mapB.get(getterName), same(getterG));
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject + 1);
+    expect(mapB[getterName], same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_accessor_with() {
     // class A { int get g; }
     // class B extends Object with A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG =
         ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement>[getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType>[classA.type];
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject + 1);
-    expect(mapB.get(getterName), same(getterG));
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject + 1);
+    expect(mapB[getterName], same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_implicitExtends() {
     // class A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
     _assertNoErrors(classA);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_getter_method() {
     // class I1 { int m(); }
     // class I2 { int get m; }
     // class A implements I2, I1 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement>[methodM];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter =
         ElementFactory.getterElement(methodName, false, _typeProvider.intType);
     classI2.accessors = <PropertyAccessorElement>[getter];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI2.type, classI1.type];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapA.get(methodName), isNull);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapA[methodName], isNull);
     _assertErrors(classA,
         [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_int_str() {
     // class I1 { int m(); }
     // class I2 { String m(); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM1 =
         ElementFactory.methodElement(methodName, null, [_typeProvider.intType]);
     classI1.methods = <MethodElement>[methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     MethodElement methodM2 = ElementFactory
         .methodElement(methodName, null, [_typeProvider.stringType]);
     classI2.methods = <MethodElement>[methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapA.get(methodName), isNull);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapA[methodName], isNull);
     _assertErrors(
         classA, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_method_getter() {
     // class I1 { int m(); }
     // class I2 { int get m; }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement>[methodM];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter =
         ElementFactory.getterElement(methodName, false, _typeProvider.intType);
     classI2.accessors = <PropertyAccessorElement>[getter];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapA.get(methodName), isNull);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapA[methodName], isNull);
     _assertErrors(classA,
         [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_numOfRequiredParams() {
     // class I1 { dynamic m(int, [int]); }
     // class I2 { dynamic m(int, int, int); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
@@ skipping 26 matching lines @@
     parameter5.type = _typeProvider.intType;
     parameter5.parameterKind = ParameterKind.REQUIRED;
     methodM2.parameters = <ParameterElement>[
       parameter3,
       parameter4,
       parameter5
     ];
     classI2.methods = <MethodElement>[methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapA.get(methodName), isNull);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapA[methodName], isNull);
     _assertErrors(
         classA, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_str_int() {
     // class I1 { int m(); }
     // class I2 { String m(); }
     // class A implements I2, I1 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM1 = ElementFactory
         .methodElement(methodName, null, [_typeProvider.stringType]);
     classI1.methods = <MethodElement>[methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     MethodElement methodM2 =
         ElementFactory.methodElement(methodName, null, [_typeProvider.intType]);
     classI2.methods = <MethodElement>[methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI2.type, classI1.type];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapA.get(methodName), isNull);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapA[methodName], isNull);
     _assertErrors(
         classA, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_method_extends() {
     // class A { int g(); }
     // class B extends A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
     MethodElement methodM =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement>[methodM];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject + 1);
-    expect(mapB.get(methodName), same(methodM));
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject + 1);
+    expect(mapB[methodName], same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_method_implements() {
     // class A { int g(); }
     // class B implements A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
     MethodElement methodM =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement>[methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType>[classA.type];
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject + 1);
-    expect(mapB.get(methodName), same(methodM));
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject + 1);
+    expect(mapB[methodName], same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_method_with() {
     // class A { int g(); }
     // class B extends Object with A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
     MethodElement methodM =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement>[methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType>[classA.type];
-    MemberMap mapB =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject);
-    expect(mapB.size, _numOfMembersInObject + 1);
-    expect(mapB.get(methodName), same(methodM));
+    Map<String, ExecutableElement> mapB =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classB);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject);
+    expect(mapB.length, _numOfMembersInObject + 1);
+    expect(mapB[methodName], same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_differentNames() {
     // class I1 { int m1(); }
     // class I2 { int m2(); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName1 = "m1";
     MethodElement methodM1 =
         ElementFactory.methodElement(methodName1, _typeProvider.intType);
     classI1.methods = <MethodElement>[methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     String methodName2 = "m2";
     MethodElement methodM2 =
         ElementFactory.methodElement(methodName2, _typeProvider.intType);
     classI2.methods = <MethodElement>[methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject + 2);
-    expect(mapA.get(methodName1), same(methodM1));
-    expect(mapA.get(methodName2), same(methodM2));
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject + 2);
+    expect(mapA[methodName1], same(methodM1));
+    expect(mapA[methodName2], same(methodM2));
     _assertNoErrors(classA);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_getters() {
     // class I1 { int get g; }
     // class I2 { num get g; }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String accessorName = "g";
     PropertyAccessorElement getter1 = ElementFactory.getterElement(
         accessorName, false, _typeProvider.intType);
     classI1.accessors = <PropertyAccessorElement>[getter1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter2 = ElementFactory.getterElement(
         accessorName, false, _typeProvider.numType);
     classI2.accessors = <PropertyAccessorElement>[getter2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject + 1);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject + 1);
     PropertyAccessorElement syntheticAccessor = ElementFactory.getterElement(
         accessorName, false, _typeProvider.dynamicType);
-    expect(mapA.get(accessorName).type, syntheticAccessor.type);
+    expect(mapA[accessorName].type, syntheticAccessor.type);
     _assertNoErrors(classA);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_methods() {
     // class I1 { dynamic m(int); }
     // class I2 { dynamic m(num); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElementImpl methodM1 =
         ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
     ParameterElementImpl parameter1 =
         new ParameterElementImpl.forNode(AstFactory.identifier3("a0"));
     parameter1.type = _typeProvider.intType;
     parameter1.parameterKind = ParameterKind.REQUIRED;
     methodM1.parameters = <ParameterElement>[parameter1];
     classI1.methods = <MethodElement>[methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     MethodElementImpl methodM2 =
         ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
     ParameterElementImpl parameter2 =
         new ParameterElementImpl.forNode(AstFactory.identifier3("a0"));
     parameter2.type = _typeProvider.numType;
     parameter2.parameterKind = ParameterKind.REQUIRED;
     methodM2.parameters = <ParameterElement>[parameter2];
     classI2.methods = <MethodElement>[methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject + 1);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject + 1);
     MethodElement syntheticMethod = ElementFactory.methodElement(
         methodName, _typeProvider.dynamicType, [_typeProvider.dynamicType]);
-    expect(mapA.get(methodName).type, syntheticMethod.type);
+    expect(mapA[methodName].type, syntheticMethod.type);
     _assertNoErrors(classA);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_setters() {
     // class I1 { set s(int); }
     // class I2 { set s(num); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String accessorName = "s";
     PropertyAccessorElement setter1 = ElementFactory.setterElement(
         accessorName, false, _typeProvider.intType);
     classI1.accessors = <PropertyAccessorElement>[setter1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement setter2 = ElementFactory.setterElement(
         accessorName, false, _typeProvider.numType);
     classI2.accessors = <PropertyAccessorElement>[setter2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject + 1);
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject + 1);
     PropertyAccessorElementImpl syntheticAccessor = ElementFactory
         .setterElement(accessorName, false, _typeProvider.dynamicType);
     syntheticAccessor.returnType = _typeProvider.dynamicType;
-    expect(mapA.get("$accessorName=").type, syntheticAccessor.type);
+    expect(mapA["$accessorName="].type, syntheticAccessor.type);
     _assertNoErrors(classA);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_getters() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { A get g; }
     // class I2 { B get g; }
@@ skipping 14 matching lines @@
     ClassElementImpl classI3 = ElementFactory.classElement2("I3");
     PropertyAccessorElement getter3 =
         ElementFactory.getterElement(accessorName, false, classC.type);
     classI3.accessors = <PropertyAccessorElement>[getter3];
     ClassElementImpl classD = ElementFactory.classElement2("D");
     classD.interfaces = <InterfaceType>[
       classI1.type,
       classI2.type,
       classI3.type
     ];
-    MemberMap mapD =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
-    expect(mapD.size, _numOfMembersInObject + 1);
+    Map<String, ExecutableElement> mapD =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classD);
+    expect(mapD.length, _numOfMembersInObject + 1);
     PropertyAccessorElement syntheticAccessor = ElementFactory.getterElement(
         accessorName, false, _typeProvider.dynamicType);
-    expect(mapD.get(accessorName).type, syntheticAccessor.type);
+    expect(mapD[accessorName].type, syntheticAccessor.type);
     _assertNoErrors(classD);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_methods() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { dynamic m(A a); }
     // class I2 { dynamic m(B b); }
@@ skipping 29 matching lines @@
     parameter3.type = classC.type;
     parameter3.parameterKind = ParameterKind.REQUIRED;
     methodM3.parameters = <ParameterElement>[parameter3];
     classI3.methods = <MethodElement>[methodM3];
     ClassElementImpl classD = ElementFactory.classElement2("D");
     classD.interfaces = <InterfaceType>[
       classI1.type,
       classI2.type,
       classI3.type
     ];
-    MemberMap mapD =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
-    expect(mapD.size, _numOfMembersInObject + 1);
+    Map<String, ExecutableElement> mapD =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classD);
+    expect(mapD.length, _numOfMembersInObject + 1);
     MethodElement syntheticMethod = ElementFactory.methodElement(
         methodName, _typeProvider.dynamicType, [_typeProvider.dynamicType]);
-    expect(mapD.get(methodName).type, syntheticMethod.type);
+    expect(mapD[methodName].type, syntheticMethod.type);
     _assertNoErrors(classD);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_setters() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { set s(A); }
     // class I2 { set s(B); }
@@ skipping 14 matching lines @@
     ClassElementImpl classI3 = ElementFactory.classElement2("I3");
     PropertyAccessorElement setter3 =
         ElementFactory.setterElement(accessorName, false, classC.type);
     classI3.accessors = <PropertyAccessorElement>[setter3];
     ClassElementImpl classD = ElementFactory.classElement2("D");
     classD.interfaces = <InterfaceType>[
       classI1.type,
       classI2.type,
       classI3.type
     ];
-    MemberMap mapD =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
-    expect(mapD.size, _numOfMembersInObject + 1);
+    Map<String, ExecutableElement> mapD =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classD);
+    expect(mapD.length, _numOfMembersInObject + 1);
     PropertyAccessorElementImpl syntheticAccessor = ElementFactory
         .setterElement(accessorName, false, _typeProvider.dynamicType);
     syntheticAccessor.returnType = _typeProvider.dynamicType;
-    expect(mapD.get("$accessorName=").type, syntheticAccessor.type);
+    expect(mapD["$accessorName="].type, syntheticAccessor.type);
     _assertNoErrors(classD);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_2_methods() {
     // class I1 { int m(); }
     // class I2 { int m([int]); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM1 =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement>[methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     MethodElementImpl methodM2 =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     ParameterElementImpl parameter1 =
         new ParameterElementImpl.forNode(AstFactory.identifier3("a1"));
     parameter1.type = _typeProvider.intType;
     parameter1.parameterKind = ParameterKind.POSITIONAL;
     methodM2.parameters = <ParameterElement>[parameter1];
     classI2.methods = <MethodElement>[methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject + 1);
-    expect(mapA.get(methodName), same(methodM2));
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject + 1);
+    expect(mapA[methodName], same(methodM2));
     _assertNoErrors(classA);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_3_methods() {
     // class I1 { int m(); }
     // class I2 { int m([int]); }
     // class I3 { int m([int, int]); }
     // class A implements I1, I2, I3 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
@@ skipping 22 matching lines @@
     parameter3.type = _typeProvider.intType;
     parameter3.parameterKind = ParameterKind.POSITIONAL;
     methodM3.parameters = <ParameterElement>[parameter2, parameter3];
     classI3.methods = <MethodElement>[methodM3];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[
       classI1.type,
       classI2.type,
       classI3.type
     ];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject + 1);
-    expect(mapA.get(methodName), same(methodM3));
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject + 1);
+    expect(mapA[methodName], same(methodM3));
     _assertNoErrors(classA);
   }
 
   void
       test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_4_methods() {
     // class I1 { int m(); }
     // class I2 { int m(); }
     // class I3 { int m([int]); }
     // class I4 { int m([int, int]); }
     // class A implements I1, I2, I3, I4 {}
@@ skipping 28 matching lines @@
     parameter3.parameterKind = ParameterKind.POSITIONAL;
     methodM4.parameters = <ParameterElement>[parameter2, parameter3];
     classI4.methods = <MethodElement>[methodM4];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[
       classI1.type,
       classI2.type,
       classI3.type,
       classI4.type
     ];
-    MemberMap mapA =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    expect(mapA.size, _numOfMembersInObject + 1);
-    expect(mapA.get(methodName), same(methodM4));
+    Map<String, ExecutableElement> mapA =
+        _inheritanceManager.getMembersInheritedFromInterfaces(classA);
+    expect(mapA.length, _numOfMembersInObject + 1);
+    expect(mapA[methodName], same(methodM4));
     _assertNoErrors(classA);
   }
 
   void test_lookupInheritance_interface_getter() {
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG =
         ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement>[getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B");
@@ skipping 382 matching lines @@
         new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     CompilationUnitElementImpl definingCompilationUnit =
         new CompilationUnitElementImpl("test.dart");
     definingCompilationUnit.librarySource =
         definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
     return new InheritanceManager(_definingLibrary);
   }
 }