TBR Revert "Remove MemberMap in favor of HashMap"

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.
    */
-  Map<ClassElement, Map<String, ExecutableElement>> _classLookup;
+  HashMap<ClassElement, MemberMap> _classLookup;
 
   /**
    * This is a mapping between each [ClassElement] and a map between the [String] member
    * names and the associated [ExecutableElement] in the interface set.
    */
-  Map<ClassElement, Map<String, ExecutableElement>> _interfaceLookup;
+  HashMap<ClassElement, MemberMap> _interfaceLookup;
 
   /**
    * A map between each visited [ClassElement] and the set of [AnalysisError]s found on
    * the class element.
    */
-  Map<ClassElement, Set<AnalysisError>> _errorsInClassElement =
-      new HashMap<ClassElement, Set<AnalysisError>>();
+  HashMap<ClassElement, HashSet<AnalysisError>> _errorsInClassElement =
+      new HashMap<ClassElement, HashSet<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, Map<String, ExecutableElement>>();
-    _interfaceLookup =
-        new HashMap<ClassElement, Map<String, ExecutableElement>>();
+    _classLookup = new HashMap<ClassElement, MemberMap>();
+    _interfaceLookup = new HashMap<ClassElement, MemberMap>();
   }
 
   /**
    * Set the new library element context.
    *
    * @param library the new library element
    */
   void set libraryElement(LibraryElement library) {
     this._library = library;
   }
@@ skipping 10 matching lines @@
       _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]
    */
-  Map<String, ExecutableElement> getMapOfMembersInheritedFromClasses(
-          ClassElement classElt) =>
+  MemberMap getMapOfMembersInheritedFromClasses(ClassElement classElt) =>
       _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].
    */
-  Map<String, ExecutableElement> getMapOfMembersInheritedFromInterfaces(
-          ClassElement classElt) =>
+  MemberMap getMapOfMembersInheritedFromInterfaces(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>())[memberName];
+    ExecutableElement executable =
+        _computeClassChainLookupMap(classElt, new HashSet<ClassElement>())
+            .get(memberName);
     if (executable == null) {
-      return _computeInterfaceLookupMap(classElt, new HashSet<ClassElement>())[
-          memberName];
+      return _computeInterfaceLookupMap(classElt, new HashSet<ClassElement>())
+          .get(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<Map<String, ExecutableElement>> interfaceMaps =
+    List<MemberMap> interfaceMaps =
         _gatherInterfaceLookupMaps(classElt, new HashSet<ClassElement>());
     if (interfaceMaps != null) {
-      for (Map<String, ExecutableElement> interfaceMap in interfaceMaps) {
-        ExecutableElement overriddenElement = interfaceMap[memberName];
+      for (MemberMap interfaceMap in interfaceMaps) {
+        ExecutableElement overriddenElement = interfaceMap.get(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]
    */
-  Map<String, ExecutableElement> _computeClassChainLookupMap(
+  MemberMap _computeClassChainLookupMap(
       ClassElement classElt, HashSet<ClassElement> visitedClasses) {
-    Map<String, ExecutableElement> resultMap = _classLookup[classElt];
+    MemberMap resultMap = _classLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
-      resultMap = new HashMap<String, ExecutableElement>();
+      resultMap = new MemberMap();
     }
     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 HashMap<String, ExecutableElement>.from(
+          resultMap = new MemberMap.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 {
-            Map<String, ExecutableElement> map =
-                new HashMap<String, ExecutableElement>.from(
-                    _computeClassChainLookupMap(mixinElement, visitedClasses));
+            MemberMap map = new MemberMap.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 (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;
+            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);
+                  }
                 }
               }
             }
           } 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]
    */
-  Map<String, ExecutableElement> _computeInterfaceLookupMap(
+  MemberMap _computeInterfaceLookupMap(
       ClassElement classElt, HashSet<ClassElement> visitedInterfaces) {
-    Map<String, ExecutableElement> resultMap = _interfaceLookup[classElt];
+    MemberMap resultMap = _interfaceLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     }
-    List<Map<String, ExecutableElement>> lookupMaps =
+    List<MemberMap> lookupMaps =
         _gatherInterfaceLookupMaps(classElt, visitedInterfaces);
     if (lookupMaps == null) {
-      resultMap = new HashMap<String, ExecutableElement>();
+      resultMap = new MemberMap();
     } else {
-      Map<String, List<ExecutableElement>> unionMap =
+      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<Map<String, ExecutableElement>> _gatherInterfaceLookupMaps(
+  List<MemberMap> _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<Map<String, ExecutableElement>> lookupMaps =
-        new List<Map<String, ExecutableElement>>();
+    List<MemberMap> lookupMaps = new List<MemberMap>();
     //
     // Superclass element
     //
     if (superclassElement != null) {
       if (!visitedInterfaces.contains(superclassElement)) {
         try {
           visitedInterfaces.add(superclassElement);
           //
           // Recursively compute the map for the super type.
           //
-          Map<String, ExecutableElement> map =
+          MemberMap map =
               _computeInterfaceLookupMap(superclassElement, visitedInterfaces);
-          map = new HashMap<String, ExecutableElement>.from(map);
+          map = new MemberMap.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.
             //
-            Map<String, ExecutableElement> map =
+            MemberMap map =
                 _computeInterfaceLookupMap(mixinElement, visitedInterfaces);
-            map = new HashMap<String, ExecutableElement>.from(map);
+            map = new MemberMap.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.
             //
-            Map<String, ExecutableElement> map =
+            MemberMap map =
                 _computeInterfaceLookupMap(interfaceElement, visitedInterfaces);
-            map = new HashMap<String, ExecutableElement>.from(map);
+            map = new MemberMap.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 42 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(Map<String, ExecutableElement> map,
-      InterfaceType type, bool doIncludeAbstract) {
+  void _recordMapWithClassMembers(
+      MemberMap 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[method.name] = method;
+        map.put(method.name, method);
       }
     }
     List<PropertyAccessorElement> accessors = type.accessors;
     for (PropertyAccessorElement accessor in accessors) {
       if (accessor.isAccessibleIn(_library) &&
           !accessor.isStatic &&
           (doIncludeAbstract || !accessor.isAbstract)) {
-        map[accessor.name] = accessor;
+        map.put(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].
    */
-  Map<String, ExecutableElement> _resolveInheritanceLookup(
-      ClassElement classElt, Map<String, List<ExecutableElement>> unionMap) {
-    Map<String, ExecutableElement> resultMap =
-        new HashMap<String, ExecutableElement>();
+  MemberMap _resolveInheritanceLookup(ClassElement classElt,
+      HashMap<String, List<ExecutableElement>> unionMap) {
+    MemberMap resultMap = new MemberMap();
     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[key] = list[0];
+        resultMap.put(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[key] = elements[subtypesOfAllOtherTypesIndexes[0]];
+            resultMap.put(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[key] = mergedExecutableElement;
+              resultMap.put(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 the given [map], and perform type
-   * parameter substitutions using a passed [supertype].
+   * 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
    */
   void _substituteTypeParametersDownHierarchy(
-      InterfaceType superType, Map<String, ExecutableElement> map) {
-    for (String memberName in map.keys) {
-      ExecutableElement executableElement = map[memberName];
+      InterfaceType superType, MemberMap map) {
+    for (int i = 0; i < map.size; i++) {
+      ExecutableElement executableElement = map.getValue(i);
       if (executableElement is MethodMember) {
         executableElement =
             MethodMember.from(executableElement as MethodMember, superType);
-        map[memberName] = executableElement;
+        map.setValue(i, executableElement);
       } else if (executableElement is PropertyAccessorMember) {
         executableElement = PropertyAccessorMember.from(
             executableElement as PropertyAccessorMember, superType);
-        map[memberName] = executableElement;
+        map.setValue(i, 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.
    */
-  Map<String, List<ExecutableElement>> _unionInterfaceLookupMaps(
-      List<Map<String, ExecutableElement>> lookupMaps) {
-    Map<String, List<ExecutableElement>> unionMap =
+  HashMap<String, List<ExecutableElement>> _unionInterfaceLookupMaps(
+      List<MemberMap> lookupMaps) {
+    HashMap<String, List<ExecutableElement>> unionMap =
         new HashMap<String, List<ExecutableElement>>();
-    for (Map<String, ExecutableElement> lookupMap in lookupMaps) {
-      for (String memberName in lookupMap.keys) {
+    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;
+        }
         // Get the list value out of the unionMap
-        List<ExecutableElement> list = unionMap[memberName];
+        List<ExecutableElement> list = unionMap[key];
         // 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[memberName] = list;
+          unionMap[key] = list;
         }
         // Fetch the entry out of this lookupMap
-        ExecutableElement newExecutableElementEntry = lookupMap[memberName];
+        ExecutableElement newExecutableElementEntry = lookupMap.getValue(i);
         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 208 matching lines @@
     NOT_INIT,
     INIT_IN_DECLARATION,
     INIT_IN_FIELD_FORMAL,
     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.
+ */
+class MemberMap {
+  /**
+   * The current size of this map.
+   */
+  int _size = 0;
+
+  /**
+   * The array of keys.
+   */
+  List<String> _keys;
+
+  /**
+   * The array of ExecutableElement values.
+   */
+  List<ExecutableElement> _values;
+
+  /**
+   * Initialize a newly created member map to have the given [initialCapacity].
+   * The map will grow if needed.
+   */
+  MemberMap([int initialCapacity = 10]) {
+    _initArrays(initialCapacity);
+  }
+
+  /**
+   * Initialize a newly created member map to contain the same members as the
+   * given [memberMap].
+   */
+  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;
+  }
+
+  /**
+   * 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.
+   *
+   * @param key some key to look up in the map
+   * @return the associated ExecutableElement value from the map, if the key does not exist in the
+   *         map, `null` is returned
+   */
+  ExecutableElement get(String key) {
+    for (int i = 0; i < _size; i++) {
+      if (_keys[i] != null && _keys[i] == key) {
+        return _values[i];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get and return the key at the specified location. If the key/value pair has been removed from
+   * the set, then `null` is returned.
+   *
+   * @param i some non-zero value less than size
+   * @return the key at the passed index
+   * @throw ArrayIndexOutOfBoundsException this exception is thrown if the passed index is less than
+   *        zero or greater than or equal to the capacity of the arrays
+   */
+  String getKey(int i) => _keys[i];
+
+  /**
+   * Get and return the ExecutableElement at the specified location. If the key/value pair has been
+   * removed from the set, then then `null` is returned.
+   *
+   * @param i some non-zero value less than size
+   * @return the key at the passed index
+   * @throw ArrayIndexOutOfBoundsException this exception is thrown if the passed index is less than
+   *        zero or greater than or equal to the capacity of the arrays
+   */
+  ExecutableElement getValue(int i) => _values[i];
+
+  /**
+   * Given some key/value pair, store the pair in the map. If the key exists already, then the new
+   * value overrides the old value.
+   *
+   * @param key the key to store in the map
+   * @param value the ExecutableElement value to store in the map
+   */
+  void put(String key, ExecutableElement value) {
+    // If we already have a value with this key, override the value
+    for (int i = 0; i < _size; i++) {
+      if (_keys[i] != null && _keys[i] == key) {
+        _values[i] = value;
+        return;
+      }
+    }
+    // If needed, double the size of our arrays and copy values over in both
+    // arrays
+    if (_size == _keys.length) {
+      int newArrayLength = _size * 2;
+      List<String> keys_new_array = new List<String>(newArrayLength);
+      List<ExecutableElement> values_new_array =
+          new List<ExecutableElement>(newArrayLength);
+      for (int i = 0; i < _size; i++) {
+        keys_new_array[i] = _keys[i];
+      }
+      for (int i = 0; i < _size; i++) {
+        values_new_array[i] = _values[i];
+      }
+      _keys = keys_new_array;
+      _values = values_new_array;
+    }
+    // Put new value at end of array
+    _keys[_size] = key;
+    _values[_size] = value;
+    _size++;
+  }
+
+  /**
+   * Given some [String] key, this method replaces the associated key and value pair with
+   * `null`. The size is not decremented with this call, instead it is expected that the users
+   * check for `null`.
+   *
+   * @param key the key of the key/value pair to remove from the map
+   */
+  void remove(String key) {
+    for (int i = 0; i < _size; i++) {
+      if (_keys[i] == key) {
+        _keys[i] = null;
+        _values[i] = null;
+        return;
+      }
+    }
+  }
+
+  /**
+   * Sets the ExecutableElement at the specified location.
+   *
+   * @param i some non-zero value less than size
+   * @param value the ExecutableElement value to store in the map
+   */
+  void setValue(int i, ExecutableElement value) {
+    _values[i] = value;
+  }
+
+  /**
+   * Initializes [keys] and [values].
+   */
+  void _initArrays(int initialCapacity) {
+    _keys = new List<String>(initialCapacity);
+    _values = new List<ExecutableElement>(initialCapacity);
+  }
+}
+
+/**
  * Instances of the class `OverrideVerifier` visit all of the declarations in a compilation
  * unit to verify that if they have an override annotation it is being used correctly.
  */
 class OverrideVerifier extends RecursiveAstVisitor<Object> {
   /**
    * The error reporter used to report errors.
    */
   final ErrorReporter _errorReporter;
 
   /**
@@ skipping 5884 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }