Remove references to and uses of MemberMap

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 4825 matching lines @@
 class InheritanceManager {
   /**
    * The [LibraryElement] that is managed by this manager.
    */
   LibraryElement _library;
 
   /**
    * This is a mapping between each [ClassElement] and a map between the [String] member
    * names and the associated [ExecutableElement] in the mixin and superclass chain.
    */
-  HashMap<ClassElement, MemberMap> _classLookup;
+  Map<ClassElement, Map<String, ExecutableElement>> _classLookup;
 
   /**
    * This is a mapping between each [ClassElement] and a map between the [String] member
    * names and the associated [ExecutableElement] in the interface set.
    */
-  HashMap<ClassElement, MemberMap> _interfaceLookup;
+  Map<ClassElement, Map<String, ExecutableElement>> _interfaceLookup;
 
   /**
    * A map between each visited [ClassElement] and the set of [AnalysisError]s found on
    * the class element.
    */
-  HashMap<ClassElement, HashSet<AnalysisError>> _errorsInClassElement =
-      new HashMap<ClassElement, HashSet<AnalysisError>>();
+  Map<ClassElement, Set<AnalysisError>> _errorsInClassElement =
+      new HashMap<ClassElement, Set<AnalysisError>>();
 
   /**
    * Initialize a newly created inheritance manager.
    *
    * @param library the library element context that the inheritance mappings are being generated
    */
   InheritanceManager(LibraryElement library) {
     this._library = library;
-    _classLookup = new HashMap<ClassElement, MemberMap>();
-    _interfaceLookup = new HashMap<ClassElement, MemberMap>();
+    _classLookup = new HashMap<ClassElement, Map<String, ExecutableElement>>();
+    _interfaceLookup = new HashMap<ClassElement, Map<String, ExecutableElement>>();
   }
 
   /**
    * Set the new library element context.
    *
    * @param library the new library element
    */
   void set libraryElement(LibraryElement library) {
     this._library = library;
   }
 
   /**
    * Return the set of [AnalysisError]s found on the passed [ClassElement], or
    * `null` if there are none.
    *
    * @param classElt the class element to query
    * @return the set of [AnalysisError]s found on the passed [ClassElement], or
    *         `null` if there are none
    */
-  HashSet<AnalysisError> getErrors(ClassElement classElt) =>
+  Set<AnalysisError> getErrors(ClassElement classElt) =>
       _errorsInClassElement[classElt];
 
   /**
    * Get and return a mapping between the set of all string names of the members inherited from the
    * passed [ClassElement] superclass hierarchy, and the associated [ExecutableElement].
    *
    * @param classElt the class element to query
    * @return a mapping between the set of all members inherited from the passed [ClassElement]
    *         superclass hierarchy, and the associated [ExecutableElement]
    */
+  @deprecated
   MemberMap getMapOfMembersInheritedFromClasses(ClassElement classElt) =>
-      _computeClassChainLookupMap(classElt, new HashSet<ClassElement>());
+      new MemberMap.fromMap(_computeClassChainLookupMap(classElt, new HashSet<ClassElement>()));
 
   /**
    * Get and return a mapping between the set of all string names of the members inherited from the
    * passed [ClassElement] interface hierarchy, and the associated [ExecutableElement].
    *
    * @param classElt the class element to query
    * @return a mapping between the set of all string names of the members inherited from the passed
    *         [ClassElement] interface hierarchy, and the associated [ExecutableElement].
    */
+  @deprecated
   MemberMap getMapOfMembersInheritedFromInterfaces(ClassElement classElt) =>
+      new MemberMap.fromMap(_computeInterfaceLookupMap(classElt, new HashSet<ClassElement>()));
+
+  /**
+   * Return a table mapping the string names of the members inherited from the
+   * passed [ClassElement]'s superclass hierarchy, and the associated executable
+   * element.
+   */
+  Map<String, ExecutableElement> getMembersInheritedFromClasses(ClassElement classElt) =>
+      _computeClassChainLookupMap(classElt, new HashSet<ClassElement>());
+
+  /**
+   * Return a table mapping the string names of the members inherited from the
+   * passed [ClassElement]'s interface hierarchy, and the associated executable
+   * element.
+   */
+  Map<String, ExecutableElement> getMembersInheritedFromInterfaces(ClassElement classElt) =>
       _computeInterfaceLookupMap(classElt, new HashSet<ClassElement>());
 
   /**
    * Given some [ClassElement] and some member name, this returns the
    * [ExecutableElement] that the class inherits from the mixins,
    * superclasses or interfaces, that has the member name, if no member is inherited `null` is
    * returned.
    *
    * @param classElt the class element to query
    * @param memberName the name of the executable element to find and return
    * @return the inherited executable element with the member name, or `null` if no such
    *         member exists
    */
   ExecutableElement lookupInheritance(
       ClassElement classElt, String memberName) {
     if (memberName == null || memberName.isEmpty) {
       return null;
     }
     ExecutableElement executable =
         _computeClassChainLookupMap(classElt, new HashSet<ClassElement>())
-            .get(memberName);
+            [memberName];
     if (executable == null) {
       return _computeInterfaceLookupMap(classElt, new HashSet<ClassElement>())
-          .get(memberName);
+          [memberName];
     }
     return executable;
   }
 
   /**
    * Given some [ClassElement] and some member name, this returns the
    * [ExecutableElement] that the class either declares itself, or
    * inherits, that has the member name, if no member is inherited `null` is returned.
    *
    * @param classElt the class element to query
@@ skipping 18 matching lines @@
    * @param classElt the class to query
    * @param memberName the name of the class member to query
    * @return a list of overridden methods
    */
   List<ExecutableElement> lookupOverrides(
       ClassElement classElt, String memberName) {
     List<ExecutableElement> result = new List<ExecutableElement>();
     if (memberName == null || memberName.isEmpty) {
       return result;
     }
-    List<MemberMap> interfaceMaps =
+    List<Map<String, ExecutableElement>> interfaceMaps =
         _gatherInterfaceLookupMaps(classElt, new HashSet<ClassElement>());
     if (interfaceMaps != null) {
-      for (MemberMap interfaceMap in interfaceMaps) {
-        ExecutableElement overriddenElement = interfaceMap.get(memberName);
+      for (Map<String, ExecutableElement> interfaceMap in interfaceMaps) {
+        ExecutableElement overriddenElement = interfaceMap[memberName];
         if (overriddenElement != null) {
           if (overriddenElement is MultiplyInheritedExecutableElement) {
             MultiplyInheritedExecutableElement multiplyInheritedElement =
                 overriddenElement;
             for (ExecutableElement element
                 in multiplyInheritedElement.inheritedElements) {
               result.add(element);
             }
           } else {
             result.add(overriddenElement);
@@ skipping 50 matching lines @@
    * Compute and return a mapping between the set of all string names of the members inherited from
    * the passed [ClassElement] superclass hierarchy, and the associated
    * [ExecutableElement].
    *
    * @param classElt the class element to query
    * @param visitedClasses a set of visited classes passed back into this method when it calls
    *          itself recursively
    * @return a mapping between the set of all string names of the members inherited from the passed
    *         [ClassElement] superclass hierarchy, and the associated [ExecutableElement]
    */
-  MemberMap _computeClassChainLookupMap(
-      ClassElement classElt, HashSet<ClassElement> visitedClasses) {
-    MemberMap resultMap = _classLookup[classElt];
+  Map<String, ExecutableElement> _computeClassChainLookupMap(
+      ClassElement classElt, Set<ClassElement> visitedClasses) {
+    Map<String, ExecutableElement> resultMap = _classLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
-      resultMap = new MemberMap();
+      resultMap = new Map<String, ExecutableElement>();
     }
     ClassElement superclassElt = null;
     InterfaceType supertype = classElt.supertype;
     if (supertype != null) {
       superclassElt = supertype.element;
     } else {
       // classElt is Object
       _classLookup[classElt] = resultMap;
       return resultMap;
     }
     if (superclassElt != null) {
       if (!visitedClasses.contains(superclassElt)) {
         visitedClasses.add(superclassElt);
         try {
-          resultMap = new MemberMap.from(
+          resultMap = new Map<String, ExecutableElement>.from(
               _computeClassChainLookupMap(superclassElt, visitedClasses));
           //
           // Substitute the super types down the hierarchy.
           //
           _substituteTypeParametersDownHierarchy(supertype, resultMap);
           //
           // Include the members from the superclass in the resultMap.
           //
           _recordMapWithClassMembers(resultMap, supertype, false);
         } finally {
@@ skipping 12 matching lines @@
     // multiple mixins, visit them in the order listed so that methods in later
     // mixins will overwrite identically-named methods in earlier mixins.
     //
     List<InterfaceType> mixins = classElt.mixins;
     for (InterfaceType mixin in mixins) {
       ClassElement mixinElement = mixin.element;
       if (mixinElement != null) {
         if (!visitedClasses.contains(mixinElement)) {
           visitedClasses.add(mixinElement);
           try {
-            MemberMap map = new MemberMap.from(
+            Map<String, ExecutableElement> map = new Map<String, ExecutableElement>.from(
                 _computeClassChainLookupMap(mixinElement, visitedClasses));
             //
             // Substitute the super types down the hierarchy.
             //
             _substituteTypeParametersDownHierarchy(mixin, map);
             //
             // Include the members from the superclass in the resultMap.
             //
             _recordMapWithClassMembers(map, mixin, false);
             //
             // Add the members from map into result map.
             //
-            for (int j = 0; j < map.size; j++) {
-              String key = map.getKey(j);
-              ExecutableElement value = map.getValue(j);
-              if (key != null) {
-                ClassElement definingClass = value
-                    .getAncestor((Element element) => element is ClassElement);
-                if (!definingClass.type.isObject) {
-                  ExecutableElement existingValue = resultMap.get(key);
-                  if (existingValue == null ||
-                      (existingValue != null && !_isAbstract(value))) {
-                    resultMap.put(key, value);
-                  }
+            for (String memberName in map.keys) {
+              ExecutableElement value = map[memberName];
+              ClassElement definingClass = value
+                  .getAncestor((Element element) => element is ClassElement);
+              if (!definingClass.type.isObject) {
+                ExecutableElement existingValue = resultMap[memberName];
+                if (existingValue == null ||
+                    (existingValue != null && !_isAbstract(value))) {
+                  resultMap[memberName] = value;
                 }
               }
             }
           } finally {
             visitedClasses.remove(mixinElement);
           }
         } else {
           // This case happens only when the superclass was previously visited
           // and not in the lookup, meaning this is meant to shorten the compute
           // for recursive cases.
@@ skipping 74 matching lines @@
    * Compute and return a mapping between the set of all string names of the members inherited from
    * the passed [ClassElement] interface hierarchy, and the associated
    * [ExecutableElement].
    *
    * @param classElt the class element to query
    * @param visitedInterfaces a set of visited classes passed back into this method when it calls
    *          itself recursively
    * @return a mapping between the set of all string names of the members inherited from the passed
    *         [ClassElement] interface hierarchy, and the associated [ExecutableElement]
    */
-  MemberMap _computeInterfaceLookupMap(
+  Map<String, ExecutableElement> _computeInterfaceLookupMap(
       ClassElement classElt, HashSet<ClassElement> visitedInterfaces) {
-    MemberMap resultMap = _interfaceLookup[classElt];
+    Map<String, ExecutableElement> resultMap = _interfaceLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     }
-    List<MemberMap> lookupMaps =
+    List<Map<String, ExecutableElement>> lookupMaps =
         _gatherInterfaceLookupMaps(classElt, visitedInterfaces);
     if (lookupMaps == null) {
-      resultMap = new MemberMap();
+      resultMap = new Map<String, ExecutableElement>();
     } else {
       HashMap<String, List<ExecutableElement>> unionMap =
           _unionInterfaceLookupMaps(lookupMaps);
       resultMap = _resolveInheritanceLookup(classElt, unionMap);
     }
     _interfaceLookup[classElt] = resultMap;
     return resultMap;
   }
 
   /**
    * Collect a list of interface lookup maps whose elements correspond to all of the classes
    * directly above [classElt] in the class hierarchy (the direct superclass if any, all
    * mixins, and all direct superinterfaces). Each item in the list is the interface lookup map
    * returned by [computeInterfaceLookupMap] for the corresponding super, except with type
    * parameters appropriately substituted.
    *
    * @param classElt the class element to query
    * @param visitedInterfaces a set of visited classes passed back into this method when it calls
    *          itself recursively
    * @return `null` if there was a problem (such as a loop in the class hierarchy) or if there
    *         are no classes above this one in the class hierarchy. Otherwise, a list of interface
    *         lookup maps.
    */
-  List<MemberMap> _gatherInterfaceLookupMaps(
+  List<Map<String, ExecutableElement>> _gatherInterfaceLookupMaps(
       ClassElement classElt, HashSet<ClassElement> visitedInterfaces) {
     InterfaceType supertype = classElt.supertype;
     ClassElement superclassElement =
         supertype != null ? supertype.element : null;
     List<InterfaceType> mixins = classElt.mixins;
     List<InterfaceType> interfaces = classElt.interfaces;
     // Recursively collect the list of mappings from all of the interface types
-    List<MemberMap> lookupMaps = new List<MemberMap>();
+    List<Map<String, ExecutableElement>> lookupMaps = new List<Map<String, ExecutableElement>>();
     //
     // Superclass element
     //
     if (superclassElement != null) {
       if (!visitedInterfaces.contains(superclassElement)) {
         try {
           visitedInterfaces.add(superclassElement);
           //
           // Recursively compute the map for the super type.
           //
-          MemberMap map =
+          Map<String, ExecutableElement> map =
               _computeInterfaceLookupMap(superclassElement, visitedInterfaces);
-          map = new MemberMap.from(map);
+          map = new Map<String, ExecutableElement>.from(map);
           //
           // Substitute the super type down the hierarchy.
           //
           _substituteTypeParametersDownHierarchy(supertype, map);
           //
           // Add any members from the super type into the map as well.
           //
           _recordMapWithClassMembers(map, supertype, true);
           lookupMaps.add(map);
         } finally {
           visitedInterfaces.remove(superclassElement);
         }
       } else {
         return null;
       }
     }
     //
     // Mixin elements
     //
     for (int i = mixins.length - 1; i >= 0; i--) {
       InterfaceType mixinType = mixins[i];
       ClassElement mixinElement = mixinType.element;
       if (mixinElement != null) {
         if (!visitedInterfaces.contains(mixinElement)) {
           try {
             visitedInterfaces.add(mixinElement);
             //
             // Recursively compute the map for the mixin.
             //
-            MemberMap map =
+            Map<String, ExecutableElement> map =
                 _computeInterfaceLookupMap(mixinElement, visitedInterfaces);
-            map = new MemberMap.from(map);
+            map = new Map<String, ExecutableElement>.from(map);
             //
             // Substitute the mixin type down the hierarchy.
             //
             _substituteTypeParametersDownHierarchy(mixinType, map);
             //
             // Add any members from the mixin type into the map as well.
             //
             _recordMapWithClassMembers(map, mixinType, true);
             lookupMaps.add(map);
           } finally {
             visitedInterfaces.remove(mixinElement);
           }
         } else {
           return null;
         }
       }
     }
     //
     // Interface elements
     //
     for (InterfaceType interfaceType in interfaces) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
         if (!visitedInterfaces.contains(interfaceElement)) {
           try {
             visitedInterfaces.add(interfaceElement);
             //
             // Recursively compute the map for the interfaces.
             //
-            MemberMap map =
+            Map<String, ExecutableElement> map =
                 _computeInterfaceLookupMap(interfaceElement, visitedInterfaces);
-            map = new MemberMap.from(map);
+            map = new Map<String, ExecutableElement>.from(map);
             //
             // Substitute the supertypes down the hierarchy
             //
             _substituteTypeParametersDownHierarchy(interfaceType, map);
             //
             // And add any members from the interface into the map as well.
             //
             _recordMapWithClassMembers(map, interfaceType, true);
             lookupMaps.add(map);
           } finally {
@@ skipping 43 matching lines @@
   /**
    * Record the passed map with the set of all members (methods, getters and setters) in the type
    * into the passed map.
    *
    * @param map some non-`null` map to put the methods and accessors from the passed
    *          [ClassElement] into
    * @param type the type that will be recorded into the passed map
    * @param doIncludeAbstract `true` if abstract members will be put into the map
    */
   void _recordMapWithClassMembers(
-      MemberMap map, InterfaceType type, bool doIncludeAbstract) {
+      Map<String, ExecutableElement> map, InterfaceType type, bool doIncludeAbstract) {
     List<MethodElement> methods = type.methods;
     for (MethodElement method in methods) {
       if (method.isAccessibleIn(_library) &&
           !method.isStatic &&
           (doIncludeAbstract || !method.isAbstract)) {
-        map.put(method.name, method);
+        map[method.name] = method;
       }
     }
     List<PropertyAccessorElement> accessors = type.accessors;
     for (PropertyAccessorElement accessor in accessors) {
       if (accessor.isAccessibleIn(_library) &&
           !accessor.isStatic &&
           (doIncludeAbstract || !accessor.isAbstract)) {
-        map.put(accessor.name, accessor);
+        map[accessor.name] = accessor;
       }
     }
   }
 
   /**
    * This method is used to report errors on when they are found computing inheritance information.
    * See [ErrorVerifier.checkForInconsistentMethodInheritance] to see where these generated
    * error codes are reported back into the analysis engine.
    *
    * @param classElt the location of the source for which the exception occurred
@@ skipping 18 matching lines @@
    * apply the appropriate inheritance rules to determine those methods inherited by or overridden
    * by [classElt]. Also report static warnings
    * [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE] and
    * [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD] if appropriate.
    *
    * @param classElt the class element to query.
    * @param unionMap a mapping from method name to the set of unique (in terms of signature) methods
    *          defined in superclasses of [classElt].
    * @return the inheritance lookup map for [classElt].
    */
-  MemberMap _resolveInheritanceLookup(ClassElement classElt,
-      HashMap<String, List<ExecutableElement>> unionMap) {
-    MemberMap resultMap = new MemberMap();
+  Map<String, ExecutableElement> _resolveInheritanceLookup(ClassElement classElt,
+      Map<String, List<ExecutableElement>> unionMap) {
+    Map<String, ExecutableElement> resultMap = new Map<String, ExecutableElement>();
     unionMap.forEach((String key, List<ExecutableElement> list) {
       int numOfEltsWithMatchingNames = list.length;
       if (numOfEltsWithMatchingNames == 1) {
         //
         // Example: class A inherits only 1 method named 'm'.
         // Since it is the only such method, it is inherited.
         // Another example: class A inherits 2 methods named 'm' from 2
         // different interfaces, but they both have the same signature, so it is
         // the method inherited.
         //
-        resultMap.put(key, list[0]);
+        resultMap[key] = list[0];
       } else {
         //
         // Then numOfEltsWithMatchingNames > 1, check for the warning cases.
         //
         bool allMethods = true;
         bool allSetters = true;
         bool allGetters = true;
         for (ExecutableElement executableElement in list) {
           if (executableElement is PropertyAccessorElement) {
             allMethods = false;
@@ skipping 51 matching lines @@
           //
           if (subtypesOfAllOtherTypesIndexes.length == 1) {
             //
             // Example: class A inherited only 2 method named 'm'.
             // One has the function type '() -> dynamic' and one has the
             // function type '([int]) -> dynamic'. Since the second method is a
             // subtype of all the others, it is the inherited method.
             // Tests: InheritanceManagerTest.
             // test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_*
             //
-            resultMap.put(key, elements[subtypesOfAllOtherTypesIndexes[0]]);
+            resultMap[key] = elements[subtypesOfAllOtherTypesIndexes[0]];
           } else {
             if (subtypesOfAllOtherTypesIndexes.isEmpty) {
               //
               // Determine if the current class has a method or accessor with
               // the member name, if it does then then this class does not
               // "inherit" from any of the supertypes. See issue 16134.
               //
               bool classHasMember = false;
               if (allMethods) {
                 classHasMember = classElt.getMethod(key) != null;
@@ skipping 33 matching lines @@
               //
               List<ExecutableElement> elementArrayToMerge =
                   new List<ExecutableElement>(
                       subtypesOfAllOtherTypesIndexes.length);
               for (int i = 0; i < elementArrayToMerge.length; i++) {
                 elementArrayToMerge[i] =
                     elements[subtypesOfAllOtherTypesIndexes[i]];
               }
               ExecutableElement mergedExecutableElement =
                   _computeMergedExecutableElement(elementArrayToMerge);
-              resultMap.put(key, mergedExecutableElement);
+              resultMap[key] = mergedExecutableElement;
             }
           }
         } else {
           _reportError(
               classElt,
               classElt.nameOffset,
               classElt.nameLength,
               StaticWarningCode
                   .INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
               [key]);
         }
       }
     });
     return resultMap;
   }
 
   /**
-   * Loop through all of the members in some [MemberMap], performing type parameter
-   * substitutions using a passed supertype.
-   *
-   * @param superType the supertype to substitute into the members of the [MemberMap]
-   * @param map the MemberMap to perform the substitutions on
+   * Loop through all of the members in the given [map], performing type
+   * parameter  substitutions using a passed [supertype].
    */
   void _substituteTypeParametersDownHierarchy(
-      InterfaceType superType, MemberMap map) {
-    for (int i = 0; i < map.size; i++) {
-      ExecutableElement executableElement = map.getValue(i);
+      InterfaceType superType, Map<String, ExecutableElement> map) {
+    for (String memberName in map.keys) {
+      ExecutableElement executableElement = map[memberName];
       if (executableElement is MethodMember) {
         executableElement =
             MethodMember.from(executableElement as MethodMember, superType);
-        map.setValue(i, executableElement);
+        map[memberName] = executableElement;
       } else if (executableElement is PropertyAccessorMember) {
         executableElement = PropertyAccessorMember.from(
             executableElement as PropertyAccessorMember, superType);
-        map.setValue(i, executableElement);
+        map[memberName] = executableElement;
       }
     }
   }
 
   /**
    * Union all of the [lookupMaps] together into a single map, grouping the ExecutableElements
    * into a list where none of the elements are equal where equality is determined by having equal
    * function types. (We also take note too of the kind of the element: ()->int and () -> int may
    * not be equal if one is a getter and the other is a method.)
    *
    * @param lookupMaps the maps to be unioned together.
    * @return the resulting union map.
    */
   HashMap<String, List<ExecutableElement>> _unionInterfaceLookupMaps(
-      List<MemberMap> lookupMaps) {
+      List<Map<String, ExecutableElement>> lookupMaps) {
     HashMap<String, List<ExecutableElement>> unionMap =
         new HashMap<String, List<ExecutableElement>>();
-    for (MemberMap lookupMap in lookupMaps) {
-      int lookupMapSize = lookupMap.size;
-      for (int i = 0; i < lookupMapSize; i++) {
-        // Get the string key, if null, break.
-        String key = lookupMap.getKey(i);
-        if (key == null) {
-          break;
-        }
+    for (Map<String, ExecutableElement> lookupMap in lookupMaps) {
+      for (String memberName in lookupMap.keys) {
         // Get the list value out of the unionMap
-        List<ExecutableElement> list = unionMap[key];
+        List<ExecutableElement> list = unionMap[memberName];
         // If we haven't created such a map for this key yet, do create it and
         // put the list entry into the unionMap.
         if (list == null) {
           list = new List<ExecutableElement>();
-          unionMap[key] = list;
+          unionMap[memberName] = list;
         }
         // Fetch the entry out of this lookupMap
-        ExecutableElement newExecutableElementEntry = lookupMap.getValue(i);
+        ExecutableElement newExecutableElementEntry = lookupMap[memberName];
         if (list.isEmpty) {
           // If the list is empty, just the new value
           list.add(newExecutableElementEntry);
         } else {
           // Otherwise, only add the newExecutableElementEntry if it isn't
           // already in the list, this covers situation where a class inherits
           // two methods (or two getters) that are identical.
           bool alreadyInList = false;
           bool isMethod1 = newExecutableElementEntry is MethodElement;
           for (ExecutableElement executableElementInList in list) {
@@ skipping 211 matching lines @@
     INIT_IN_INITIALIZERS
   ];
 
   const INIT_STATE(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * This class is used to replace uses of `HashMap<String, ExecutableElement>`
  * which are not as performant as this class.
  */
+@deprecated
 class MemberMap {
   /**
    * The current size of this map.
    */
   int _size = 0;
 
   /**
    * The array of keys.
    */
   List<String> _keys;
@@ skipping 18 matching lines @@
   MemberMap.from(MemberMap memberMap) {
     _initArrays(memberMap._size + 5);
     for (int i = 0; i < memberMap._size; i++) {
       _keys[i] = memberMap._keys[i];
       _values[i] = memberMap._values[i];
     }
     _size = memberMap._size;
   }
 
   /**
+   * Initialize a newly created member map to contain the same members as the
+   * given [map].
+   */
+  MemberMap.fromMap(Map<String, ExecutableElement> map) {
+    _size = map.length;
+    _initArrays(_size + 5);
+    int index = 0;
+    map.forEach((String memberName, ExecutableElement element) {
+      _keys[index] = memberName;
+      _values[index] = element;
+      index++;
+    });
+  }
+
+  /**
    * The size of the map.
    *
    * @return the size of the map.
    */
   int get size => _size;
 
   /**
    * Given some key, return the ExecutableElement value from the map, if the key does not exist in
    * the map, `null` is returned.
    *
@@ skipping 6003 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }