New analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/resolver.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.resolver;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
+import 'utilities_dart.dart';
 import 'utilities_general.dart';
-import 'utilities_dart.dart';
 import 'ast.dart';
 import 'parser.dart' show Parser, ParserErrorCode;
 import 'sdk.dart' show DartSdk, SdkLibrary;
 import 'element.dart';
 import 'html.dart' as ht;
 import 'engine.dart';
 import 'constant.dart';
 /**
  * Instances of the class `CompilationUnitBuilder` build an element model for a single
  * compilation unit.
@@ skipping 3300 matching lines @@
     Expression target = node.realTarget;
     if (target is SuperExpression && !isSuperInValidContext(target as SuperExpression)) {
       return null;
     }
     Element staticElement;
     Element propagatedElement;
     if (target == null) {
       staticElement = resolveInvokedElement2(methodName);
       propagatedElement = null;
     } else {
-      staticElement = resolveInvokedElement(target, getStaticType(target), methodName);
+      Type2 staticType = getStaticType(target);
+      staticElement = resolveInvokedElement(target, staticType, methodName);
       propagatedElement = resolveInvokedElement(target, getPropagatedType(target), methodName);
     }
     staticElement = convertSetterToGetter(staticElement);
     propagatedElement = convertSetterToGetter(propagatedElement);
     methodName.staticElement = staticElement;
     methodName.propagatedElement = propagatedElement;
     ArgumentList argumentList = node.argumentList;
     if (staticElement != null) {
       List<ParameterElement> parameters = computeCorrespondingParameters(argumentList, staticElement);
       if (parameters != null) {
@@ skipping 343 matching lines @@
           if (useStaticContext) {
             targetType = getStaticType(target);
           } else {
             targetType = getPropagatedType(target);
             if (targetType == null) {
               targetType = getStaticType(target);
             }
           }
           if (targetType == null) {
             return CompileTimeErrorCode.UNDEFINED_FUNCTION;
-          } else if (!targetType.isDynamic) {
+          } else if (!targetType.isDynamic && !targetType.isBottom) {
             return StaticTypeWarningCode.UNDEFINED_METHOD;
           }
         }
       }
     }
     return null;
   }
 
   /**
    * Check that the for some index expression that the method element was resolved, otherwise a
@@ skipping 159 matching lines @@
   }
 
   /**
    * Return the static type of the given expression that is to be used for type analysis.
    *
    * @param expression the expression whose type is to be returned
    * @return the type of the given expression
    */
   Type2 getStaticType(Expression expression) {
     if (expression is NullLiteral) {
-      return _resolver.typeProvider.objectType;
+      return _resolver.typeProvider.bottomType;
     }
     Type2 staticType = resolveTypeParameter(expression.staticType);
     if (staticType is FunctionType) {
       staticType = _resolver.typeProvider.functionType;
     }
     return staticType;
   }
 
   /**
    * Return the element representing the superclass of the given class.
@@ skipping 837 matching lines @@
 
   /**
    * Return `true` if we should report an error as a result of looking up a member in the
    * given type and not finding any member.
    *
    * @param type the type in which we attempted to perform the look-up
    * @param member the result of the look-up
    * @return `true` if we should report an error
    */
   bool shouldReportMissingMember(Type2 type, ExecutableElement member) {
-    if (member != null || type == null || type.isDynamic) {
+    if (member != null || type == null || type.isDynamic || type.isBottom) {
       return false;
     }
     return true;
   }
 }
 /**
  * Instances of the class `SyntheticIdentifier` implement an identifier that can be used to
  * look up names in the lexical scope when there is no identifier in the AST structure. There is
  * no identifier in the AST when the parser could not distinguish between a method invocation and
  * an invocation of a top-level function imported with a prefix.
@@ skipping 33 matching lines @@
 
   /**
    * 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;
+  Map<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;
+  Map<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 Map<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 Map<ClassElement, Map<String, ExecutableElement>>();
-    _interfaceLookup = new Map<ClassElement, Map<String, ExecutableElement>>();
+    _classLookup = new Map<ClassElement, MemberMap>();
+    _interfaceLookup = new Map<ClassElement, MemberMap>();
   }
 
   /**
    * 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
    */
   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]
    */
-  Map<String, ExecutableElement> getMapOfMembersInheritedFromClasses(ClassElement classElt) => computeClassChainLookupMap(classElt, new Set<ClassElement>());
+  MemberMap getMapOfMembersInheritedFromClasses(ClassElement classElt) => computeClassChainLookupMap(classElt, new Set<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) => computeInterfaceLookupMap(classElt, new Set<ClassElement>());
+  MemberMap getMapOfMembersInheritedFromInterfaces(ClassElement classElt) => computeInterfaceLookupMap(classElt, new Set<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 Set<ClassElement>())[memberName];
+    ExecutableElement executable = computeClassChainLookupMap(classElt, new Set<ClassElement>()).get(memberName);
     if (executable == null) {
-      return computeInterfaceLookupMap(classElt, new Set<ClassElement>())[memberName];
+      return computeInterfaceLookupMap(classElt, new Set<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 70 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(ClassElement classElt, Set<ClassElement> visitedClasses) {
-    Map<String, ExecutableElement> resultMap = _classLookup[classElt];
+  MemberMap computeClassChainLookupMap(ClassElement classElt, Set<ClassElement> visitedClasses) {
+    MemberMap resultMap = _classLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
-      resultMap = new Map<String, ExecutableElement>();
+      resultMap = new MemberMap();
     }
     ClassElement superclassElt = null;
     InterfaceType supertype = classElt.supertype;
     if (supertype != null) {
       superclassElt = supertype.element;
     } else {
       _classLookup[classElt] = resultMap;
       return resultMap;
     }
     if (superclassElt != null) {
       if (!visitedClasses.contains(superclassElt)) {
         javaSetAdd(visitedClasses, classElt);
-        resultMap = new Map<String, ExecutableElement>.from(computeClassChainLookupMap(superclassElt, visitedClasses));
+        resultMap = new MemberMap.con2(computeClassChainLookupMap(superclassElt, visitedClasses));
       } else {
         _classLookup[superclassElt] = resultMap;
         return resultMap;
       }
       recordMapWithClassMembers(resultMap, supertype);
     }
     List<InterfaceType> mixins = classElt.mixins;
     for (int i = mixins.length - 1; i >= 0; i--) {
       recordMapWithClassMembers(resultMap, mixins[i]);
     }
@@ skipping 52 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(ClassElement classElt, Set<ClassElement> visitedInterfaces) {
-    Map<String, ExecutableElement> resultMap = _interfaceLookup[classElt];
+  MemberMap computeInterfaceLookupMap(ClassElement classElt, Set<ClassElement> visitedInterfaces) {
+    MemberMap resultMap = _interfaceLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
-      resultMap = new Map<String, ExecutableElement>();
+      resultMap = new MemberMap();
     }
     InterfaceType supertype = classElt.supertype;
     ClassElement superclassElement = supertype != null ? supertype.element : null;
     List<InterfaceType> mixins = classElt.mixins;
     List<InterfaceType> interfaces = classElt.interfaces;
-    List<Map<String, ExecutableElement>> lookupMaps = new List<Map<String, ExecutableElement>>();
+    List<MemberMap> lookupMaps = new List<MemberMap>();
     if (superclassElement != null) {
       if (!visitedInterfaces.contains(superclassElement)) {
         try {
           javaSetAdd(visitedInterfaces, superclassElement);
-          Map<String, ExecutableElement> map = computeInterfaceLookupMap(superclassElement, visitedInterfaces);
-          map = new Map<String, ExecutableElement>.from(map);
+          MemberMap map = computeInterfaceLookupMap(superclassElement, visitedInterfaces);
+          map = new MemberMap.con2(map);
           List<MethodElement> methods = supertype.methods;
           for (MethodElement method in methods) {
             if (method.isAccessibleIn(_library) && !method.isStatic) {
-              map[method.name] = method;
+              map.put(method.name, method);
             }
           }
           List<PropertyAccessorElement> accessors = supertype.accessors;
           for (PropertyAccessorElement accessor in accessors) {
             if (accessor.isAccessibleIn(_library) && !accessor.isStatic) {
-              map[accessor.name] = accessor;
+              map.put(accessor.name, accessor);
             }
           }
           lookupMaps.add(map);
         } finally {
           visitedInterfaces.remove(superclassElement);
         }
       } else {
-        Map<String, ExecutableElement> map = _interfaceLookup[classElt];
+        MemberMap map = _interfaceLookup[classElt];
         if (map != null) {
           lookupMaps.add(map);
         } else {
           _interfaceLookup[superclassElement] = resultMap;
           return resultMap;
         }
       }
     }
     for (InterfaceType mixinType in mixins) {
-      Map<String, ExecutableElement> mapWithMixinMembers = new Map<String, ExecutableElement>();
+      MemberMap mapWithMixinMembers = new MemberMap();
       recordMapWithClassMembers(mapWithMixinMembers, mixinType);
       lookupMaps.add(mapWithMixinMembers);
     }
     for (InterfaceType interfaceType in interfaces) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
         if (!visitedInterfaces.contains(interfaceElement)) {
           try {
             javaSetAdd(visitedInterfaces, interfaceElement);
-            Map<String, ExecutableElement> map = computeInterfaceLookupMap(interfaceElement, visitedInterfaces);
-            map = new Map<String, ExecutableElement>.from(map);
+            MemberMap map = computeInterfaceLookupMap(interfaceElement, visitedInterfaces);
+            map = new MemberMap.con2(map);
             List<MethodElement> methods = interfaceType.methods;
             for (MethodElement method in methods) {
               if (method.isAccessibleIn(_library) && !method.isStatic) {
-                map[method.name] = method;
+                map.put(method.name, method);
               }
             }
             List<PropertyAccessorElement> accessors = interfaceType.accessors;
             for (PropertyAccessorElement accessor in accessors) {
               if (accessor.isAccessibleIn(_library) && !accessor.isStatic) {
-                map[accessor.name] = accessor;
+                map.put(accessor.name, accessor);
               }
             }
             lookupMaps.add(map);
           } finally {
             visitedInterfaces.remove(interfaceElement);
           }
         } else {
-          Map<String, ExecutableElement> map = _interfaceLookup[classElt];
+          MemberMap map = _interfaceLookup[classElt];
           if (map != null) {
             lookupMaps.add(map);
           } else {
             _interfaceLookup[interfaceElement] = resultMap;
             return resultMap;
           }
         }
       }
     }
     if (lookupMaps.length == 0) {
       _interfaceLookup[classElt] = resultMap;
       return resultMap;
     }
     Map<String, Set<ExecutableElement>> unionMap = new Map<String, Set<ExecutableElement>>();
-    for (Map<String, ExecutableElement> lookupMap in lookupMaps) {
-      for (MapEntry<String, ExecutableElement> entry in getMapEntrySet(lookupMap)) {
-        String key = entry.getKey();
+    for (MemberMap lookupMap in lookupMaps) {
+      for (int i = 0; i < lookupMap.size; i++) {
+        String key = lookupMap.getKey(i);
+        if (key == null) {
+          break;
+        }
         Set<ExecutableElement> set = unionMap[key];
         if (set == null) {
           set = new Set<ExecutableElement>();
           unionMap[key] = set;
         }
-        javaSetAdd(set, entry.getValue());
+        javaSetAdd(set, lookupMap.getValue(i));
       }
     }
     for (MapEntry<String, Set<ExecutableElement>> entry in getMapEntrySet(unionMap)) {
       String key = entry.getKey();
       Set<ExecutableElement> set = entry.getValue();
       int numOfEltsWithMatchingNames = set.length;
       if (numOfEltsWithMatchingNames == 1) {
-        resultMap[key] = new JavaIterator(set).next();
+        resultMap.put(key, new JavaIterator(set).next());
       } else {
         bool allMethods = true;
         bool allSetters = true;
         bool allGetters = true;
         for (ExecutableElement executableElement in set) {
           if (executableElement is PropertyAccessorElement) {
             allMethods = false;
             if (((executableElement as PropertyAccessorElement)).isSetter) {
               allGetters = false;
             } else {
@@ skipping 20 matching lines @@
             for (int j = 0; j < numOfEltsWithMatchingNames && subtypeOfAllTypes; j++) {
               if (i != j) {
                 if (!subtype.isSubtypeOf(executableElementTypes[j])) {
                   subtypeOfAllTypes = false;
                   break;
                 }
               }
             }
             if (subtypeOfAllTypes) {
               foundSubtypeOfAllTypes = true;
-              resultMap[key] = elements[i];
+              resultMap.put(key, elements[i]);
               break;
             }
           }
           if (!foundSubtypeOfAllTypes) {
             reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE, [key]);
           }
         } else {
           if (!allMethods && !allGetters) {
             reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD, [key]);
           }
@@ skipping 31 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
    */
-  void recordMapWithClassMembers(Map<String, ExecutableElement> map, InterfaceType type) {
+  void recordMapWithClassMembers(MemberMap map, InterfaceType type) {
     List<MethodElement> methods = type.methods;
     for (MethodElement method in methods) {
       if (method.isAccessibleIn(_library) && !method.isStatic) {
-        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) {
-        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 575 matching lines @@
       }
       buildDirectiveModels();
       instrumentation.metric3("buildDirectiveModels", "complete");
       _typeProvider = new TypeProviderImpl(coreElement);
       buildTypeHierarchies();
       instrumentation.metric3("buildTypeHierarchies", "complete");
       resolveReferencesAndTypes();
       instrumentation.metric3("resolveReferencesAndTypes", "complete");
       performConstantEvaluation();
       instrumentation.metric3("performConstantEvaluation", "complete");
-      if (fullAnalysis) {
-        runAdditionalAnalyses();
-        instrumentation.metric3("runAdditionalAnalyses", "complete");
-      }
       return targetLibrary.libraryElement;
     } finally {
       instrumentation.log();
     }
   }
 
   /**
    * Resolve the library specified by the given source in the given context.
    *
    * Note that because Dart allows circular imports between libraries, it is possible that more than
@@ skipping 27 matching lines @@
       }
       buildDirectiveModels();
       instrumentation.metric3("buildDirectiveModels", "complete");
       _typeProvider = new TypeProviderImpl(coreElement);
       buildTypeHierarchies();
       instrumentation.metric3("buildTypeHierarchies", "complete");
       resolveReferencesAndTypes();
       instrumentation.metric3("resolveReferencesAndTypes", "complete");
       performConstantEvaluation();
       instrumentation.metric3("performConstantEvaluation", "complete");
-      if (fullAnalysis) {
-        runAdditionalAnalyses();
-        instrumentation.metric3("runAdditionalAnalyses", "complete");
-      }
       instrumentation.metric2("librariesInCycles", resolvedLibraries.length);
       for (Library lib in resolvedLibraries) {
         instrumentation.metric2("librariesInCycles-CompilationUnitSources-Size", lib.compilationUnitSources.length);
       }
       return targetLibrary.libraryElement;
     } finally {
       instrumentation.log();
     }
   }
 
@@ skipping 462 matching lines @@
     if (uriLiteral is StringInterpolation) {
       return null;
     }
     String uriContent = uriLiteral.stringValue.trim();
     if (uriContent == null || uriContent.isEmpty) {
       return null;
     }
     uriContent = Uri.encodeFull(uriContent);
     return analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
   }
+}
+/**
+ * This class is used to replace uses of `HashMap<String, ExecutableElement>` which are not as
+ * performant as this class.
+ */
+class MemberMap {
 
   /**
-   * Run additional analyses, such as the [ConstantVerifier] and [ErrorVerifier]
-   * analysis in the current cycle.
+   * The current size of this map.
+   */
+  int size = 0;
+
+  /**
+   * The array of keys.
+   */
+  List<String> _keys;
+
+  /**
+   * The array of ExecutableElement values.
+   */
+  List<ExecutableElement> _values;
+
+  /**
+   * Default constructor.
+   */
+  MemberMap() : this.con1(10);
+
+  /**
+   * This constructor takes an initial capacity of the map.
    *
-   * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
-   *           the library cannot be analyzed
+   * @param initialCapacity the initial capacity
    */
-  void runAdditionalAnalyses() {
-    for (Library library in resolvedLibraries) {
-      runAdditionalAnalyses2(library);
+  MemberMap.con1(int initialCapacity) {
+    initArrays(initialCapacity);
+  }
+
+  /**
+   * Copy constructor.
+   */
+  MemberMap.con2(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;
+  }
+
+  /**
+   * 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) {
+    for (int i = 0; i < size; i++) {
+      if (_keys[i] != null && _keys[i] == key) {
+        _values[i] = value;
+        return;
+      }
+    }
+    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;
+    }
+    _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;
+      }
     }
   }
 
   /**
-   * Run additional analyses, such as the [ConstantVerifier] and [ErrorVerifier]
-   * analysis in the given library.
-   *
-   * @param library the library to have the extra analyses processes run
-   * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
-   *           the library cannot be analyzed
+   * Initializes [keys] and [values].
    */
-  void runAdditionalAnalyses2(Library library) {
-    TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.errors.start();
-    for (Source source in library.compilationUnitSources) {
-      ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
-      CompilationUnit unit = library.getAST(source);
-      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _typeProvider);
-      unit.accept(constantVerifier);
-      ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, library.libraryElement, _typeProvider, library.inheritanceManager);
-      unit.accept(errorVerifier);
-    }
-    timeCounter.stop();
+  void initArrays(int initialCapacity) {
+    _keys = new List<String>(initialCapacity);
+    _values = new List<ExecutableElement>(initialCapacity);
   }
 }
 /**
  * This class is a wrapper for an [AnalysisError] which can also be queried after resolution
  * to find out if the error should actually be reported. In this case, these errors are conditional
  * on the non-existence of an `@proxy` annotation.
  *
  * If we have other conditional error codes in the future, we should have this class implement some
  * ConditionalErrorCode so that after resolution, a list of ConditionalErrorCode can be visited
  * instead of multiple lists of *ConditionalErrorCodes.
@@ skipping 576 matching lines @@
 
   /**
    * If it is appropriate to do so, override the current type of the given element with the given
    * type. Generally speaking, it is appropriate if the given type is more specific than the current
    * type.
    *
    * @param element the element whose type might be overridden
    * @param potentialType the potential type of the element
    */
   void override2(VariableElement element, Type2 potentialType) {
-    if (potentialType == null || identical(potentialType, BottomTypeImpl.instance)) {
+    if (potentialType == null || potentialType.isBottom) {
       return;
     }
     if (element is PropertyInducingElement) {
       PropertyInducingElement variable = element as PropertyInducingElement;
       if (!variable.isConst && !variable.isFinal) {
         return;
       }
     }
     Type2 currentType = getBestType(element);
     if (currentType == null || !currentType.isMoreSpecificThan(potentialType)) {
@@ skipping 1965 matching lines @@
    * Compute the static return type of the method or function represented by the given element.
    *
    * @param element the element representing the method or function invoked by the given node
    * @return the static return type that was computed
    */
   Type2 computeStaticReturnType(Element element) {
     if (element is PropertyAccessorElement) {
       FunctionType propertyType = ((element as PropertyAccessorElement)).type;
       if (propertyType != null) {
         Type2 returnType = propertyType.returnType;
-        if (returnType is InterfaceType) {
-          if (identical(returnType, _typeProvider.functionType)) {
-            return _dynamicType;
-          }
+        if (returnType.isDartCoreFunction) {
+          return _dynamicType;
+        } else if (returnType is InterfaceType) {
           MethodElement callMethod = ((returnType as InterfaceType)).lookUpMethod(ElementResolver.CALL_METHOD_NAME, _resolver.definingLibrary);
           if (callMethod != null) {
             return callMethod.type.returnType;
           }
         } else if (returnType is FunctionType) {
           Type2 innerReturnType = ((returnType as FunctionType)).returnType;
           if (innerReturnType != null) {
             return innerReturnType;
           }
-        } else if (returnType.isDartCoreFunction) {
-          return _dynamicType;
         }
         if (returnType != null) {
           return returnType;
         }
       }
     } else if (element is ExecutableElement) {
       FunctionType type = ((element as ExecutableElement)).type;
       if (type != null) {
         return type.returnType;
       }
@@ skipping 243 matching lines @@
    * @param functionElement the function element to record propagated return type for
    * @param body the boy of the function whose propagated return type is to be computed
    * @return the propagated return type that was computed, may be `null` if it is not more
    *         specific than the static return type.
    */
   void recordPropagatedType(ExecutableElement functionElement, FunctionBody body) {
     Type2 propagatedReturnType = computePropagatedReturnType2(body);
     if (propagatedReturnType == null) {
       return;
     }
-    if (identical(propagatedReturnType, BottomTypeImpl.instance)) {
+    if (propagatedReturnType.isBottom) {
       return;
     }
     Type2 staticReturnType = functionElement.returnType;
     if (!propagatedReturnType.isMoreSpecificThan(staticReturnType)) {
       return;
     }
     _propagatedReturnTypes[functionElement] = propagatedReturnType;
   }
 
   /**
@@ skipping 529 matching lines @@
  * Instances of the class `TypeResolverVisitor` are used to resolve the types associated with
  * the elements in the element model. This includes the types of superclasses, mixins, interfaces,
  * fields, methods, parameters, and local variables. As a side-effect, this also finishes building
  * the type hierarchy.
  *
  * @coverage dart.engine.resolver
  */
 class TypeResolverVisitor extends ScopedVisitor {
 
   /**
+   * @return `true` if the name of the given [TypeName] is an built-in identifier.
+   */
+  static bool isBuiltInIdentifier(TypeName node) {
+    sc.Token token = node.name.beginToken;
+    return identical(token.type, sc.TokenType.KEYWORD);
+  }
+
+  /**
+   * @return `true` if given [TypeName] is used as a type annotation.
+   */
+  static bool isTypeAnnotation(TypeName node) {
+    ASTNode parent = node.parent;
+    if (parent is VariableDeclarationList) {
+      return identical(((parent as VariableDeclarationList)).type, node);
+    }
+    if (parent is FieldFormalParameter) {
+      return identical(((parent as FieldFormalParameter)).type, node);
+    }
+    if (parent is SimpleFormalParameter) {
+      return identical(((parent as SimpleFormalParameter)).type, node);
+    }
+    return false;
+  }
+
+  /**
    * The type representing the type 'dynamic'.
    */
   Type2 _dynamicType;
 
   /**
    * The flag specifying if currently visited class references 'super' expression.
    */
   bool _hasReferenceToSuper = false;
 
   /**
@@ skipping 263 matching lines @@
         elementValid = false;
       } else {
         if (element != null) {
           reportError5(StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
           elementValid = false;
         }
       }
     }
     if (elementValid && element == null) {
       SimpleIdentifier typeNameSimple = getTypeSimpleIdentifier(typeName);
-      if (typeNameSimple.name == "boolean") {
+      if (isBuiltInIdentifier(node) && isTypeAnnotation(node)) {
+        reportError5(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, typeName, [typeName.name]);
+      } else if (typeNameSimple.name == "boolean") {
         reportError5(StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, typeNameSimple, []);
       } else if (isTypeNameInCatchClause(node)) {
         reportError5(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
       } else if (isTypeNameInAsExpression(node)) {
         reportError5(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (isTypeNameInIsExpression(node)) {
         reportError5(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
       } else if (isTypeNameTargetInRedirectedConstructor(node)) {
         reportError5(StaticWarningCode.REDIRECT_TO_NON_CLASS, typeName, [typeName.name]);
       } else if (isTypeNameInTypeArgumentList(node)) {
@@ skipping 870 matching lines @@
       String libName1 = "", libName2 = "";
       List<Element> conflictingMembers = ((foundElement as MultiplyDefinedElementImpl)).conflictingElements;
       LibraryElement enclosingLibrary = conflictingMembers[0].getAncestor(LibraryElement);
       if (enclosingLibrary != null) {
         libName1 = enclosingLibrary.definingCompilationUnit.displayName;
       }
       enclosingLibrary = conflictingMembers[1].getAncestor(LibraryElement);
       if (enclosingLibrary != null) {
         libName2 = enclosingLibrary.definingCompilationUnit.displayName;
       }
-      _errorListener.onError(new AnalysisError.con2(source, identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [foundEltName, libName1, libName2]));
+      _errorListener.onError(new AnalysisError.con2(getSource2(identifier), identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [foundEltName, libName1, libName2]));
       return foundElement;
     }
     if (foundElement != null) {
       defineWithoutChecking2(name, foundElement);
     }
     return foundElement;
   }
 
   /**
    * Create all of the namespaces associated with the libraries imported into this library. The
    * names are not added to this scope, but are stored for later reference.
    *
    * @param definingLibrary the element representing the library that imports the libraries for
    *          which namespaces will be created
    */
   void createImportedNamespaces(LibraryElement definingLibrary) {
     NamespaceBuilder builder = new NamespaceBuilder();
     for (ImportElement element in definingLibrary.imports) {
       _importedNamespaces.add(builder.createImportNamespace(element));
     }
   }
 
   /**
+   * Return the source that contains the given identifier, or the source associated with this scope
+   * if the source containing the identifier could not be determined.
+   *
+   * @param identifier the identifier whose source is to be returned
+   * @return the source that contains the given identifier
+   */
+  Source getSource2(Identifier identifier) {
+    CompilationUnit unit = identifier.getAncestor(CompilationUnit);
+    if (unit != null) {
+      CompilationUnitElement element = unit.element;
+      if (element != null) {
+        Source source = element.source;
+        if (source != null) {
+          return source;
+        }
+      }
+    }
+    return this.source;
+  }
+
+  /**
    * Given a collection of elements that a single name could all be mapped to, remove from the list
    * all of the names defined in the SDK. Return the element(s) that remain.
    *
    * @param foundElement the element encapsulating the collection of elements
    * @return all of the elements that are not defined in the SDK
    */
   Element removeSdkElements(MultiplyDefinedElementImpl foundElement) {
     List<Element> conflictingMembers = foundElement.conflictingElements;
     int length = conflictingMembers.length;
     int to = 0;
@@ skipping 1511 matching lines @@
     try {
       if (initializerNode != null) {
         initializerNode.accept(this);
       }
     } finally {
       _isInInstanceVariableInitializer = false;
       _namesForReferenceToDeclaredVariableInInitializer.remove(name);
     }
     return null;
   }
-  Object visitVariableDeclarationList(VariableDeclarationList node) {
-    checkForBuiltInIdentifierAsName2(node);
-    return super.visitVariableDeclarationList(node);
-  }
+  Object visitVariableDeclarationList(VariableDeclarationList node) => super.visitVariableDeclarationList(node);
   Object visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     checkForFinalNotInitialized2(node.variables);
     return super.visitVariableDeclarationStatement(node);
   }
   Object visitWhileStatement(WhileStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitWhileStatement(node);
   }
 
   /**
@@ skipping 97 matching lines @@
    * @see StaticWarningCode#INVALID_GETTER_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE
    * @see StaticWarningCode#INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
    */
   bool checkForAllInvalidOverrideErrorCodes(ExecutableElement executableElement, List<ParameterElement> parameters, List<ASTNode> parameterLocations, SimpleIdentifier errorNameTarget) {
     String executableElementName = executableElement.name;
+    bool executableElementPrivate = Identifier.isPrivateName(executableElementName);
     ExecutableElement overriddenExecutable = _inheritanceManager.lookupInheritance(_enclosingClass, executableElementName);
     bool isGetter = false;
     bool isSetter = false;
     if (executableElement is PropertyAccessorElement) {
       PropertyAccessorElement accessorElement = executableElement as PropertyAccessorElement;
       isGetter = accessorElement.isGetter;
       isSetter = accessorElement.isSetter;
     }
     if (overriddenExecutable == null) {
       if (!isGetter && !isSetter && !executableElement.isOperator) {
         Set<ClassElement> visitedClasses = new Set<ClassElement>();
         InterfaceType superclassType = _enclosingClass.supertype;
         ClassElement superclassElement = superclassType == null ? null : superclassType.element;
         while (superclassElement != null && !visitedClasses.contains(superclassElement)) {
           javaSetAdd(visitedClasses, superclassElement);
+          LibraryElement superclassLibrary = superclassElement.library;
           List<FieldElement> fieldElts = superclassElement.fields;
           for (FieldElement fieldElt in fieldElts) {
-            if (fieldElt.name == executableElementName && fieldElt.isStatic) {
+            if (fieldElt.name != executableElementName) {
+              continue;
+            }
+            if (executableElementPrivate && _currentLibrary != superclassLibrary) {
+              continue;
+            }
+            if (fieldElt.isStatic) {
               _errorReporter.reportError2(StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC, errorNameTarget, [
                   executableElementName,
                   fieldElt.enclosingElement.displayName]);
               return true;
             }
           }
           List<MethodElement> methodElements = superclassElement.methods;
           for (MethodElement methodElement in methodElements) {
-            if (methodElement.name == executableElementName && methodElement.isStatic) {
+            if (methodElement.name != executableElementName) {
+              continue;
+            }
+            if (executableElementPrivate && _currentLibrary != superclassLibrary) {
+              continue;
+            }
+            if (methodElement.isStatic) {
               _errorReporter.reportError2(StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC, errorNameTarget, [
                   executableElementName,
                   methodElement.enclosingElement.displayName]);
               return true;
             }
           }
           superclassType = superclassElement.supertype;
           superclassElement = superclassType == null ? null : superclassType.element;
         }
       }
@@ skipping 404 matching lines @@
     }
     return problemReported;
   }
 
   /**
    * This verifies that the passed argument can be assigned to its corresponding parameter.
    *
    * @param argument the argument to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
-   * @see CompileTimeErrorCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
   bool checkForArgumentTypeNotAssignable2(Expression argument) {
     if (argument == null) {
       return false;
     }
-    ErrorCode errorCode;
-    if (_isInConstInstanceCreation || _isEnclosingConstructorConst) {
-      errorCode = CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE;
-    } else {
-      errorCode = StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE;
-    }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     Type2 staticParameterType = staticParameterElement == null ? null : staticParameterElement.type;
     ParameterElement propagatedParameterElement = argument.propagatedParameterElement;
     Type2 propagatedParameterType = propagatedParameterElement == null ? null : propagatedParameterElement.type;
-    return checkForArgumentTypeNotAssignable3(argument, staticParameterType, propagatedParameterType, errorCode);
+    return checkForArgumentTypeNotAssignable3(argument, staticParameterType, propagatedParameterType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
    * @param expression the expression to evaluate
    * @param expectedStaticType the expected static type
    * @param expectedPropagatedType the expected propagated type, may be `null`
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
-   * @see CompileTimeErrorCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
   bool checkForArgumentTypeNotAssignable3(Expression expression, Type2 expectedStaticType, Type2 expectedPropagatedType, ErrorCode errorCode) => checkForArgumentTypeNotAssignable4(expression, expectedStaticType, getStaticType(expression), expectedPropagatedType, expression.propagatedType, errorCode);
 
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
    * @param expression the expression to evaluate
    * @param expectedStaticType the expected static type of the parameter
    * @param actualStaticType the actual static type of the argument
    * @param expectedPropagatedType the expected propagated type of the parameter, may be
    *          `null`
    * @param actualPropagatedType the expected propagated type of the parameter, may be `null`
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
-   * @see CompileTimeErrorCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
   bool checkForArgumentTypeNotAssignable4(Expression expression, Type2 expectedStaticType, Type2 actualStaticType, Type2 expectedPropagatedType, Type2 actualPropagatedType, ErrorCode errorCode) {
     if (actualStaticType == null || expectedStaticType == null) {
       return false;
     }
     if (_strictMode) {
       if (actualStaticType.isAssignableTo(expectedStaticType)) {
         return false;
       }
       _errorReporter.reportError2(errorCode, expression, [
@@ skipping 89 matching lines @@
   bool checkForBuiltInIdentifierAsName(SimpleIdentifier identifier, ErrorCode errorCode) {
     sc.Token token = identifier.token;
     if (identical(token.type, sc.TokenType.KEYWORD)) {
       _errorReporter.reportError2(errorCode, identifier, [identifier.name]);
       return true;
     }
     return false;
   }
 
   /**
-   * This verifies that the passed variable declaration list does not have a built-in identifier.
-   *
-   * @param node the variable declaration list to check
-   * @return `true` if and only if an error code is generated on the passed node
-   * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE
-   */
-  bool checkForBuiltInIdentifierAsName2(VariableDeclarationList node) {
-    TypeName typeName = node.type;
-    if (typeName != null) {
-      Identifier identifier = typeName.name;
-      if (identifier is SimpleIdentifier) {
-        SimpleIdentifier simpleIdentifier = identifier as SimpleIdentifier;
-        sc.Token token = simpleIdentifier.token;
-        if (identical(token.type, sc.TokenType.KEYWORD)) {
-          if (((token as sc.KeywordToken)).keyword != sc.Keyword.DYNAMIC) {
-            _errorReporter.reportError2(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, identifier, [identifier.name]);
-            return true;
-          }
-        }
-      }
-    }
-    return false;
-  }
-
-  /**
    * This verifies that the given switch case is terminated with 'break', 'continue', 'return' or
    * 'throw'.
    *
    * @param node the switch case to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CASE_BLOCK_NOT_TERMINATED
    */
   bool checkForCaseBlockNotTerminated(SwitchCase node) {
     NodeList<Statement> statements = node.statements;
     if (statements.isEmpty) {
@@ skipping 1086 matching lines @@
   }
 
   /**
    * This verifies that an 'int' can be assigned to the parameter corresponding to the given
    * expression. This is used for prefix and postfix expressions where the argument value is
    * implicit.
    *
    * @param argument the expression to which the operator is being applied
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
-   * @see CompileTimeErrorCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
   bool checkForIntNotAssignable(Expression argument) {
     if (argument == null) {
       return false;
     }
-    ErrorCode errorCode;
-    if (_isInConstInstanceCreation || _isEnclosingConstructorConst) {
-      errorCode = CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE;
-    } else {
-      errorCode = StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE;
-    }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     Type2 staticParameterType = staticParameterElement == null ? null : staticParameterElement.type;
     ParameterElement propagatedParameterElement = argument.propagatedParameterElement;
     Type2 propagatedParameterType = propagatedParameterElement == null ? null : propagatedParameterElement.type;
-    return checkForArgumentTypeNotAssignable4(argument, staticParameterType, _typeProvider.intType, propagatedParameterType, _typeProvider.intType, errorCode);
+    return checkForArgumentTypeNotAssignable4(argument, staticParameterType, _typeProvider.intType, propagatedParameterType, _typeProvider.intType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * Given an assignment using a compound assignment operator, this verifies that the given
    * assignment is valid.
    *
    * @param node the assignment expression being tested
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INVALID_ASSIGNMENT
    */
@@ skipping 404 matching lines @@
     for (MethodElement method in methods) {
       javaSetAdd(methodsInEnclosingClass, method.name);
     }
     for (PropertyAccessorElement accessor in accessors) {
       javaSetAdd(accessorsInEnclosingClass, accessor.name);
     }
     if (methodsInEnclosingClass.contains(ElementResolver.NO_SUCH_METHOD_METHOD_NAME)) {
       return false;
     }
     Set<ExecutableElement> missingOverrides = new Set<ExecutableElement>();
-    Map<String, ExecutableElement> membersInheritedFromInterfaces = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
-    Map<String, ExecutableElement> membersInheritedFromSuperclasses = _inheritanceManager.getMapOfMembersInheritedFromClasses(_enclosingClass);
-    for (MapEntry<String, ExecutableElement> entry in getMapEntrySet(membersInheritedFromInterfaces)) {
-      ExecutableElement executableElt = entry.getValue();
-      ExecutableElement elt = membersInheritedFromSuperclasses[executableElt.name];
+    MemberMap membersInheritedFromInterfaces = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
+    MemberMap membersInheritedFromSuperclasses = _inheritanceManager.getMapOfMembersInheritedFromClasses(_enclosingClass);
+    for (int i = 0; i < membersInheritedFromInterfaces.size; i++) {
+      String memberName = membersInheritedFromInterfaces.getKey(i);
+      ExecutableElement executableElt = membersInheritedFromInterfaces.getValue(i);
+      if (memberName == null) {
+        break;
+      }
+      ExecutableElement elt = membersInheritedFromSuperclasses.get(executableElt.name);
       if (elt != null) {
         if (elt is MethodElement && !((elt as MethodElement)).isAbstract) {
           continue;
         } else if (elt is PropertyAccessorElement && !((elt as PropertyAccessorElement)).isAbstract) {
           continue;
         }
       }
       if (executableElt is MethodElement) {
-        String methodName = entry.getKey();
-        if (!methodsInEnclosingClass.contains(methodName) && !memberHasConcreteMethodImplementationInSuperclassChain(_enclosingClass, methodName, new List<ClassElement>())) {
+        if (!methodsInEnclosingClass.contains(memberName) && !memberHasConcreteMethodImplementationInSuperclassChain(_enclosingClass, memberName, new List<ClassElement>())) {
           javaSetAdd(missingOverrides, executableElt);
         }
       } else if (executableElt is PropertyAccessorElement) {
-        String accessorName = entry.getKey();
-        if (!accessorsInEnclosingClass.contains(accessorName) && !memberHasConcreteAccessorImplementationInSuperclassChain(_enclosingClass, accessorName, new List<ClassElement>())) {
+        if (!accessorsInEnclosingClass.contains(memberName) && !memberHasConcreteAccessorImplementationInSuperclassChain(_enclosingClass, memberName, new List<ClassElement>())) {
           javaSetAdd(missingOverrides, executableElt);
         }
       }
     }
     int missingOverridesSize = missingOverrides.length;
     if (missingOverridesSize == 0) {
       return false;
     }
     List<ExecutableElement> missingOverridesArray = new List.from(missingOverrides);
     List<String> stringMembersArrayListSet = new List<String>();
@@ skipping 460 matching lines @@
    * and [visitExpressionFunctionBody].
    *
    * @param returnExpression the returned expression to evaluate
    * @param expectedReturnType the expressed return type by the enclosing method or function
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
    */
   bool checkForReturnOfInvalidType(Expression returnExpression, Type2 expectedReturnType) {
     Type2 staticReturnType = getStaticType(returnExpression);
     if (expectedReturnType.isVoid) {
-      if (staticReturnType.isVoid || staticReturnType.isDynamic || identical(staticReturnType, BottomTypeImpl.instance)) {
+      if (staticReturnType.isVoid || staticReturnType.isDynamic || staticReturnType.isBottom) {
         return false;
       }
       _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
           staticReturnType.displayName,
           expectedReturnType.displayName,
           _enclosingFunction.displayName]);
       return true;
     }
     bool isStaticAssignable = staticReturnType.isAssignableTo(expectedReturnType);
     Type2 propagatedReturnType = returnExpression.propagatedType;
@@ skipping 444 matching lines @@
         }
         if (current != null && !checked.contains(current)) {
           break;
         }
       }
       current.accept(new GeneralizingElementVisitor_12(target, toCheck));
       javaSetAdd(checked, current);
     }
   }
   bool isFunctionType(Type2 type) {
-    if (type.isDynamic || identical(type, BottomTypeImpl.instance)) {
+    if (type.isDynamic || type.isBottom) {
+      return true;
+    } else if (type is FunctionType || type.isDartCoreFunction) {
       return true;
     } else if (type is InterfaceType) {
-      if (identical(type, _typeProvider.functionType)) {
-        return true;
-      }
       MethodElement callMethod = ((type as InterfaceType)).lookUpMethod(ElementResolver.CALL_METHOD_NAME, _currentLibrary);
       return callMethod != null;
-    } else if (type is FunctionType || type.isDartCoreFunction) {
-      return true;
     }
     return false;
   }
 
   /**
    * @return `true` if the given [ASTNode] is the part of constant constructor
    *         invocation.
    */
   bool isInConstConstructorInvocation(ASTNode node) {
     InstanceCreationExpression creation = node.getAncestor(InstanceCreationExpression);
@@ skipping 259 matching lines @@
   ResolverErrorCode.con2(String name, int ordinal, ErrorType type, String message, String correction) : super(name, ordinal) {
     this._type = type;
     this._message = message;
     this.correction9 = correction;
   }
   String get correction => correction9;
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
 }