New analyzer snapshot.

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.
 
 // 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';
@@ skipping 334 matching lines @@
     return argument is SimpleStringLiteral;
   }
 
   /**
    * Checks if given [Annotation] is an annotation with required name.
    */
   bool _isAngularAnnotation(Annotation annotation, String name) {
     Element element = annotation.element;
     if (element is ConstructorElement) {
       ConstructorElement constructorElement = element;
-      return constructorElement.returnType.displayName == name;
+      if (constructorElement.returnType.displayName != name) {
+        return false;
+      }
+      return _isAngularLibraryElement(constructorElement);
     }
     return false;
   }
 
+  /**
+   * Checks if the given [Element] is a part of the Angular library.
+   */
+  bool _isAngularLibraryElement(Element element) {
+    LibraryElement library = element.library;
+    return library != null && library.name != null && library.name.startsWith("angular");
+  }
+
   void _parseComponent() {
     bool isValid = true;
     // publishAs
     String name = null;
     int nameOffset = -1;
     if (_hasStringArgument(_PUBLISH_AS)) {
       name = _getStringArgument(_PUBLISH_AS);
       nameOffset = _getStringArgumentOffset(_PUBLISH_AS);
     }
     // selector
@@ skipping 533 matching lines @@
       }
     }
     //
     // Hint case: test propagated type information
     //
     // Compute the best types to use.
     DartType expectedBestType = expectedPropagatedType != null ? expectedPropagatedType : expectedStaticType;
     DartType actualBestType = actualPropagatedType != null ? actualPropagatedType : actualStaticType;
     if (actualBestType != null && expectedBestType != null) {
       if (!actualBestType.isAssignableTo(expectedBestType)) {
-        _errorReporter.reportErrorForNode(hintCode, expression, [actualBestType.displayName, expectedBestType.displayName]);
+        _errorReporter.reportTypeErrorForNode(hintCode, expression, [actualBestType, expectedBestType]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed argument can be assigned to its corresponding parameter.
    *
    * This method corresponds to ErrorCode.checkForArgumentTypeNotAssignableForArgument.
@@ skipping 151 matching lines @@
     DartType leftType = (leftVariableElement == null) ? ErrorVerifier.getStaticType(lhs) : leftVariableElement.type;
     DartType staticRightType = ErrorVerifier.getStaticType(rhs);
     if (!staticRightType.isAssignableTo(leftType)) {
       // The warning was generated on this rhs
       return false;
     }
     // Test for, and then generate the hint
     DartType bestRightType = rhs.bestType;
     if (leftType != null && bestRightType != null) {
       if (!bestRightType.isAssignableTo(leftType)) {
-        String leftName = leftType.displayName;
-        String rightName = bestRightType.displayName;
-        if (leftName == rightName) {
-          Element leftElement = leftType.element;
-          Element rightElement = bestRightType.element;
-          if (leftElement != null && rightElement != null) {
-            leftName = leftElement.extendedDisplayName;
-            rightName = rightElement.extendedDisplayName;
-          }
-        }
-        _errorReporter.reportErrorForNode(HintCode.INVALID_ASSIGNMENT, rhs, [rightName, leftName]);
+        _errorReporter.reportTypeErrorForNode(HintCode.INVALID_ASSIGNMENT, rhs, [bestRightType, leftType]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Check that the imported library does not define a loadLibrary function. The import has already
    * been determined to be deferred when this is called.
    *
@@ skipping 78 matching lines @@
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#UNNECESSARY_CAST
    */
   bool _checkForUnnecessaryCast(AsExpression node) {
     Expression expression = node.expression;
     TypeName typeName = node.type;
     DartType lhsType = expression.staticType;
     DartType rhsType = typeName.type;
     // TODO(jwren) After dartbug.com/13732, revisit this, we should be able to remove the
     // !(x instanceof TypeParameterType) checks.
-    if (lhsType != null && rhsType != null && !lhsType.isDynamic && !rhsType.isDynamic && lhsType is! TypeParameterType && rhsType is! TypeParameterType && lhsType.isSubtypeOf(rhsType)) {
+    if (lhsType != null && rhsType != null && !lhsType.isDynamic && !rhsType.isDynamic && lhsType is! TypeParameterType && rhsType is! TypeParameterType && lhsType.isMoreSpecificThan(rhsType)) {
       _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_CAST, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * Check for situations where the result of a method or function is used, when it returns 'void'.
    *
    * TODO(jwren) Many other situations of use could be covered. We currently cover the cases var x =
@@ skipping 2141 matching lines @@
    * A collection holding the function types defined in a class that need to have their type
    * arguments set to the types of the type parameters for the class, or `null` if we are not
    * currently processing nodes within a class.
    */
   List<FunctionTypeImpl> _functionTypesToFix = null;
 
   /**
    * A table mapping field names to field elements for the fields defined in the current class, or
    * `null` if we are not in the scope of a class.
    */
-  Map<String, FieldElement> _fieldMap;
+  HashMap<String, FieldElement> _fieldMap;
 
   /**
    * Initialize a newly created element builder to build the elements for a compilation unit.
    *
    * @param initialHolder the element holder associated with the compilation unit being built
    */
   ElementBuilder(ElementHolder initialHolder) {
     _currentHolder = initialHolder;
   }
 
@@ skipping 613 matching lines @@
     return null;
   }
 
   /**
    * Build the table mapping field names to field elements for the fields defined in the current
    * class.
    *
    * @param fields the field elements defined in the current class
    */
   void _buildFieldMap(List<FieldElement> fields) {
-    _fieldMap = new Map<String, FieldElement>();
+    _fieldMap = new HashMap<String, FieldElement>();
     int count = fields.length;
     for (int i = 0; i < count; i++) {
       FieldElement field = fields[i];
       _fieldMap[field.name] = field;
     }
   }
 
   /**
    * Creates the [ConstructorElement]s array with the single default constructor element.
    *
@@ skipping 2432 matching lines @@
    *
    * @param reportError if `true` then compile-time error should be reported; if `false`
    *          then compile-time warning
    * @param argumentList the list of arguments being passed to the element
    * @param parameters the of the function that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
   List<ParameterElement> _resolveArgumentsToParameters(bool reportError, ArgumentList argumentList, List<ParameterElement> parameters) {
     List<ParameterElement> requiredParameters = new List<ParameterElement>();
     List<ParameterElement> positionalParameters = new List<ParameterElement>();
-    Map<String, ParameterElement> namedParameters = new Map<String, ParameterElement>();
+    HashMap<String, ParameterElement> namedParameters = new HashMap<String, ParameterElement>();
     for (ParameterElement parameter in parameters) {
       ParameterKind kind = parameter.parameterKind;
       if (kind == ParameterKind.REQUIRED) {
         requiredParameters.add(parameter);
       } else if (kind == ParameterKind.POSITIONAL) {
         positionalParameters.add(parameter);
       } else {
         namedParameters[parameter.name] = parameter;
       }
     }
@@ skipping 477 matching lines @@
   /**
    * The scope in which this scope is lexically enclosed.
    */
   final Scope enclosingScope;
 
   /**
    * A table mapping names that will be defined in this scope, but right now are not initialized.
    * According to the scoping rules these names are hidden, even if they were defined in an outer
    * scope.
    */
-  Map<String, Element> _hiddenElements = new Map<String, Element>();
+  HashMap<String, Element> _hiddenElements = new HashMap<String, Element>();
 
   /**
    * A flag indicating whether there are any names defined in this scope.
    */
   bool _hasHiddenName = false;
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
@@ skipping 171 matching lines @@
   bool _isInFunctionTypedFormalParameter = false;
 
   /**
    * This is set to `true` iff the visitor is currently visiting a static method. By "method"
    * here getter, setter and operator declarations are also implied since they are all represented
    * with a [MethodDeclaration] in the AST structure.
    */
   bool _isInStaticMethod = false;
 
   /**
+   * This is set to `true` iff the visitor is currently visiting a factory constructor.
+   */
+  bool _isInFactory = false;
+
+  /**
    * This is set to `true` iff the visitor is currently visiting code in the SDK.
    */
   bool _isInSystemLibrary = false;
 
   /**
    * A flag indicating whether the current library contains at least one import directive with a URI
    * that uses the "dart-ext" scheme.
    */
   bool _hasExtUri = false;
 
@@ skipping 37 matching lines @@
    * When set the map maps the set of [FieldElement]s in the class to an
    * [INIT_STATE#NOT_INIT] or [INIT_STATE#INIT_IN_DECLARATION]. <code>checkFor*</code>
    * methods, specifically [checkForAllFinalInitializedErrorCodes],
    * can make a copy of the map to compute error code states. <code>checkFor*</code> methods should
    * only ever make a copy, or read from this map after it has been set in
    * [visitClassDeclaration].
    *
    * @see #visitClassDeclaration(ClassDeclaration)
    * @see #checkForAllFinalInitializedErrorCodes(ConstructorDeclaration)
    */
-  Map<FieldElement, INIT_STATE> _initialFieldElementsMap;
+  HashMap<FieldElement, INIT_STATE> _initialFieldElementsMap;
 
   /**
    * A table mapping name of the library to the export directive which export this library.
    */
-  Map<String, LibraryElement> _nameToExportElement = new Map<String, LibraryElement>();
+  HashMap<String, LibraryElement> _nameToExportElement = new HashMap<String, LibraryElement>();
 
   /**
    * A table mapping name of the library to the import directive which import this library.
    */
-  Map<String, LibraryElement> _nameToImportElement = new Map<String, LibraryElement>();
+  HashMap<String, LibraryElement> _nameToImportElement = new HashMap<String, LibraryElement>();
 
   /**
    * A table mapping names to the exported elements.
    */
-  Map<String, Element> _exportedElements = new Map<String, Element>();
+  HashMap<String, Element> _exportedElements = new HashMap<String, Element>();
 
   /**
    * A set of the names of the variable initializers we are visiting now.
    */
   Set<String> _namesForReferenceToDeclaredVariableInInitializer = new Set<String>();
 
   /**
    * A list of types used by the [CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS] and
    * [CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS] error codes.
    */
@@ skipping 162 matching lines @@
           _checkForRecursiveInterfaceInheritance(_enclosingClass);
           _checkForConflictingGetterAndMethod();
           _checkForConflictingInstanceGetterAndSuperclassMember();
           _checkImplementsSuperClass(node);
           _checkImplementsFunctionWithoutCall(node);
         }
       }
       // initialize initialFieldElementsMap
       if (_enclosingClass != null) {
         List<FieldElement> fieldElements = _enclosingClass.fields;
-        _initialFieldElementsMap = new Map<FieldElement, INIT_STATE>();
+        _initialFieldElementsMap = new HashMap<FieldElement, INIT_STATE>();
         for (FieldElement fieldElement in fieldElements) {
           if (!fieldElement.isSynthetic) {
             _initialFieldElementsMap[fieldElement] = fieldElement.initializer == null ? INIT_STATE.NOT_INIT : INIT_STATE.INIT_IN_DECLARATION;
           }
         }
       }
       _checkForFinalNotInitializedInClass(node);
       _checkForDuplicateDefinitionInheritance();
       _checkForConflictingInstanceMethodSetter(node);
       return super.visitClassDeclaration(node);
@@ skipping 47 matching lines @@
     return super.visitConditionalExpression(node);
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       ConstructorElement constructorElement = node.element;
       _enclosingFunction = constructorElement;
       _isEnclosingConstructorConst = node.constKeyword != null;
+      _isInFactory = node.factoryKeyword != null;
       _checkForConstConstructorWithNonFinalField(node, constructorElement);
       _checkForConstConstructorWithNonConstSuper(node);
       _checkForConflictingConstructorNameAndMember(node, constructorElement);
       _checkForAllFinalInitializedErrorCodes(node);
       _checkForRedirectingConstructorErrorCodes(node);
       _checkForMultipleSuperInitializers(node);
       _checkForRecursiveConstructorRedirect(node, constructorElement);
       if (!_checkForRecursiveFactoryRedirect(node, constructorElement)) {
         _checkForAllRedirectConstructorErrorCodes(node);
       }
       _checkForUndefinedConstructorInInitializerImplicit(node);
       _checkForRedirectToNonConstConstructor(node, constructorElement);
       _checkForReturnInGenerativeConstructor(node);
       return super.visitConstructorDeclaration(node);
     } finally {
       _isEnclosingConstructorConst = false;
+      _isInFactory = false;
       _enclosingFunction = outerFunction;
     }
   }
 
   @override
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     _isInConstructorInitializer = true;
     try {
       SimpleIdentifier fieldName = node.fieldName;
       Element staticElement = fieldName.staticElement;
@@ skipping 521 matching lines @@
    */
   bool _checkForAllFinalInitializedErrorCodes(ConstructorDeclaration node) {
     if (node.factoryKeyword != null || node.redirectedConstructor != null || node.externalKeyword != null) {
       return false;
     }
     // Ignore if native class.
     if (_isInNativeClass) {
       return false;
     }
     bool foundError = false;
-    Map<FieldElement, INIT_STATE> fieldElementsMap = new Map<FieldElement, INIT_STATE>.from(_initialFieldElementsMap);
+    HashMap<FieldElement, INIT_STATE> fieldElementsMap = new HashMap<FieldElement, INIT_STATE>.from(_initialFieldElementsMap);
     // Visit all of the field formal parameters
     NodeList<FormalParameter> formalParameters = node.parameters.parameters;
     for (FormalParameter formalParameter in formalParameters) {
       FormalParameter parameter = formalParameter;
       if (parameter is DefaultFormalParameter) {
         parameter = (parameter as DefaultFormalParameter).parameter;
       }
       if (parameter is FieldFormalParameter) {
         FieldElement fieldElement = (parameter.element as FieldFormalParameterElementImpl).field;
         INIT_STATE state = fieldElementsMap[fieldElement];
@@ skipping 80 matching lines @@
    */
   bool _checkForAllInvalidOverrideErrorCodes(ExecutableElement executableElement, ExecutableElement overriddenExecutable, List<ParameterElement> parameters, List<AstNode> parameterLocations, SimpleIdentifier errorNameTarget) {
     bool isGetter = false;
     bool isSetter = false;
     if (executableElement is PropertyAccessorElement) {
       PropertyAccessorElement accessorElement = executableElement;
       isGetter = accessorElement.isGetter;
       isSetter = accessorElement.isSetter;
     }
     String executableElementName = executableElement.name;
-    // SWC.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC
-    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;
-        bool executableElementPrivate = Identifier.isPrivateName(executableElementName);
-        while (superclassElement != null && !visitedClasses.contains(superclassElement)) {
-          visitedClasses.add(superclassElement);
-          LibraryElement superclassLibrary = superclassElement.library;
-          // Check fields.
-          List<FieldElement> fieldElts = superclassElement.fields;
-          for (FieldElement fieldElt in fieldElts) {
-            // We need the same name.
-            if (fieldElt.name != executableElementName) {
-              continue;
-            }
-            // Ignore if private in a different library - cannot collide.
-            if (executableElementPrivate && _currentLibrary != superclassLibrary) {
-              continue;
-            }
-            // instance vs. static
-            if (fieldElt.isStatic) {
-              _errorReporter.reportErrorForNode(StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC, errorNameTarget, [
-                  executableElementName,
-                  fieldElt.enclosingElement.displayName]);
-              return true;
-            }
-          }
-          // Check methods.
-          List<MethodElement> methodElements = superclassElement.methods;
-          for (MethodElement methodElement in methodElements) {
-            // We need the same name.
-            if (methodElement.name != executableElementName) {
-              continue;
-            }
-            // Ignore if private in a different library - cannot collide.
-            if (executableElementPrivate && _currentLibrary != superclassLibrary) {
-              continue;
-            }
-            // instance vs. static
-            if (methodElement.isStatic) {
-              _errorReporter.reportErrorForNode(StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC, errorNameTarget, [
-                  executableElementName,
-                  methodElement.enclosingElement.displayName]);
-              return true;
-            }
-          }
-          superclassType = superclassElement.supertype;
-          superclassElement = superclassType == null ? null : superclassType.element;
-        }
-      }
-      return false;
-    }
     FunctionType overridingFT = executableElement.type;
     FunctionType overriddenFT = overriddenExecutable.type;
     InterfaceType enclosingType = _enclosingClass.type;
     overriddenFT = _inheritanceManager.substituteTypeArgumentsInMemberFromInheritance(overriddenFT, executableElementName, enclosingType);
     if (overridingFT == null || overriddenFT == null) {
       return false;
     }
     DartType overridingFTReturnType = overridingFT.returnType;
     DartType overriddenFTReturnType = overriddenFT.returnType;
     List<DartType> overridingNormalPT = overridingFT.normalParameterTypes;
@@ skipping 25 matching lines @@
         // The overridden method expected the overriding method to have overridingParamName,
         // but it does not.
         _errorReporter.reportErrorForNode(StaticWarningCode.INVALID_OVERRIDE_NAMED, errorNameTarget, [
             overriddenParamName,
             overriddenExecutable.enclosingElement.displayName]);
         return true;
       }
     }
     // SWC.INVALID_METHOD_OVERRIDE_RETURN_TYPE
     if (overriddenFTReturnType != VoidTypeImpl.instance && !overridingFTReturnType.isAssignableTo(overriddenFTReturnType)) {
-      _errorReporter.reportErrorForNode(!isGetter ? StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE : StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE, errorNameTarget, [
-          overridingFTReturnType.displayName,
-          overriddenFTReturnType.displayName,
+      _errorReporter.reportTypeErrorForNode(!isGetter ? StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE : StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE, errorNameTarget, [
+          overridingFTReturnType,
+          overriddenFTReturnType,
           overriddenExecutable.enclosingElement.displayName]);
       return true;
     }
     // SWC.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
     if (parameterLocations == null) {
       return false;
     }
     int parameterIndex = 0;
     for (int i = 0; i < overridingNormalPT.length; i++) {
       if (!overridingNormalPT[i].isAssignableTo(overriddenNormalPT[i])) {
-        _errorReporter.reportErrorForNode(!isSetter ? StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE : StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE, parameterLocations[parameterIndex], [
-            overridingNormalPT[i].displayName,
-            overriddenNormalPT[i].displayName,
+        _errorReporter.reportTypeErrorForNode(!isSetter ? StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE : StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE, parameterLocations[parameterIndex], [
+            overridingNormalPT[i],
+            overriddenNormalPT[i],
             overriddenExecutable.enclosingElement.displayName]);
         return true;
       }
       parameterIndex++;
     }
     // SWC.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE
     for (int i = 0; i < overriddenPositionalPT.length; i++) {
       if (!overridingPositionalPT[i].isAssignableTo(overriddenPositionalPT[i])) {
-        _errorReporter.reportErrorForNode(StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE, parameterLocations[parameterIndex], [
-            overridingPositionalPT[i].displayName,
-            overriddenPositionalPT[i].displayName,
+        _errorReporter.reportTypeErrorForNode(StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE, parameterLocations[parameterIndex], [
+            overridingPositionalPT[i],
+            overriddenPositionalPT[i],
             overriddenExecutable.enclosingElement.displayName]);
         return true;
       }
       parameterIndex++;
     }
     // SWC.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE & SWC.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
     JavaIterator<MapEntry<String, DartType>> overriddenNamedPTIterator = new JavaIterator(getMapEntrySet(overriddenNamedPT));
     while (overriddenNamedPTIterator.hasNext) {
       MapEntry<String, DartType> overriddenNamedPTEntry = overriddenNamedPTIterator.next();
       DartType overridingType = overridingNamedPT[overriddenNamedPTEntry.getKey()];
       if (overridingType == null) {
         // Error, this is never reached- INVALID_OVERRIDE_NAMED would have been created above if
         // this could be reached.
         continue;
       }
       if (!overriddenNamedPTEntry.getValue().isAssignableTo(overridingType)) {
         // lookup the parameter for the error to select
         ParameterElement parameterToSelect = null;
         AstNode parameterLocationToSelect = null;
         for (int i = 0; i < parameters.length; i++) {
           ParameterElement parameter = parameters[i];
           if (parameter.parameterKind == ParameterKind.NAMED && overriddenNamedPTEntry.getKey() == parameter.name) {
             parameterToSelect = parameter;
             parameterLocationToSelect = parameterLocations[i];
             break;
           }
         }
         if (parameterToSelect != null) {
-          _errorReporter.reportErrorForNode(StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE, parameterLocationToSelect, [
-              overridingType.displayName,
-              overriddenNamedPTEntry.getValue().displayName,
+          _errorReporter.reportTypeErrorForNode(StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE, parameterLocationToSelect, [
+              overridingType,
+              overriddenNamedPTEntry.getValue(),
               overriddenExecutable.enclosingElement.displayName]);
           return true;
         }
       }
     }
     // SWC.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
     //
     // Create three arrays: an array of the optional parameter ASTs (FormalParameters), an array of
     // the optional parameters elements from our method, and finally an array of the optional
     // parameter elements from the method we are overriding.
@@ skipping 85 matching lines @@
    *
    * @param executableElement a non-null [ExecutableElement] to evaluate
    * @param parameters the parameters of the executable element
    * @param errorNameTarget the node to report problems on
    * @return `true` if and only if an error code is generated on the passed node
    */
   bool _checkForAllInvalidOverrideErrorCodesForExecutable(ExecutableElement executableElement, List<ParameterElement> parameters, List<AstNode> parameterLocations, SimpleIdentifier errorNameTarget) {
     //
     // Compute the overridden executable from the InheritanceManager
     //
-    ExecutableElement overriddenExecutable = _inheritanceManager.lookupInheritance(_enclosingClass, executableElement.name);
-    //
-    // If the result is a MultiplyInheritedExecutableElement call
-    // checkForAllInvalidOverrideErrorCodes on all of the elements, until an error is found.
-    //
-    if (overriddenExecutable is MultiplyInheritedExecutableElement) {
-      MultiplyInheritedExecutableElement multiplyInheritedElement = overriddenExecutable;
-      List<ExecutableElement> overriddenElement = multiplyInheritedElement.inheritedElements;
-      for (int i = 0; i < overriddenElement.length; i++) {
-        if (_checkForAllInvalidOverrideErrorCodes(executableElement, overriddenElement[i], parameters, parameterLocations, errorNameTarget)) {
-          return true;
-        }
+    List<ExecutableElement> overriddenExecutables = _inheritanceManager.lookupOverrides(_enclosingClass, executableElement.name);
+    if (overriddenExecutables.isEmpty) {
+      // Nothing is overridden, so we just have to check if the new name collides
+      // with a static defined in the superclass.
+      // TODO(paulberry): currently we don't do this check if the new element
+      // overrides a method in an interface (see issue 18947).
+      return _checkForInstanceMethodNameCollidesWithSuperclassStatic(executableElement, errorNameTarget);
+    }
+    for (ExecutableElement overriddenElement in overriddenExecutables) {
+      if (_checkForAllInvalidOverrideErrorCodes(executableElement, overriddenElement, parameters, parameterLocations, errorNameTarget)) {
+        return true;
       }
-      return false;
     }
-    //
-    // Otherwise, just call checkForAllInvalidOverrideErrorCodes.
-    //
-    return _checkForAllInvalidOverrideErrorCodes(executableElement, overriddenExecutable, parameters, parameterLocations, errorNameTarget);
+    return false;
   }
 
   /**
    * This checks the passed field declaration against override-error codes.
    *
    * @param node the [MethodDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see #checkForAllInvalidOverrideErrorCodes(ExecutableElement)
    */
   bool _checkForAllInvalidOverrideErrorCodesForField(FieldDeclaration node) {
@@ skipping 236 matching lines @@
    * @see CompileTimeErrorCode#MAP_VALUE_TYPE_NOT_ASSIGNABLE
    * @see StaticWarningCode#MAP_KEY_TYPE_NOT_ASSIGNABLE
    * @see StaticWarningCode#MAP_VALUE_TYPE_NOT_ASSIGNABLE
    */
   bool _checkForArgumentTypeNotAssignable(Expression expression, DartType expectedStaticType, DartType actualStaticType, ErrorCode errorCode) {
     //
     // Warning case: test static type information
     //
     if (actualStaticType != null && expectedStaticType != null) {
       if (!actualStaticType.isAssignableTo(expectedStaticType)) {
-        _errorReporter.reportErrorForNode(errorCode, expression, [
-            actualStaticType.displayName,
-            expectedStaticType.displayName]);
+        _errorReporter.reportTypeErrorForNode(errorCode, expression, [actualStaticType, expectedStaticType]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed argument can be assigned to its corresponding parameter.
    *
    * This method corresponds to BestPracticesVerifier.checkForArgumentTypeNotAssignableForArgument.
@@ skipping 416 matching lines @@
   bool _checkForConflictingInstanceMethodSetter(ClassDeclaration node) {
     // Reference all of the class members in this class.
     NodeList<ClassMember> classMembers = node.members;
     if (classMembers.isEmpty) {
       return false;
     }
     // Create a HashMap to track conflicting members, and then loop through members in the class to
     // construct the HashMap, at the same time, look for violations.  Don't add members if they are
     // part of a conflict, this prevents multiple warnings for one issue.
     bool foundError = false;
-    Map<String, ClassMember> memberHashMap = new Map<String, ClassMember>();
+    HashMap<String, ClassMember> memberHashMap = new HashMap<String, ClassMember>();
     for (ClassMember classMember in classMembers) {
       if (classMember is MethodDeclaration) {
         MethodDeclaration method = classMember;
         if (method.isStatic) {
           continue;
         }
         // prepare name
         SimpleIdentifier name = method.name;
         if (name == null) {
           continue;
@@ skipping 445 matching lines @@
    *
    * @param node the compilation unit containing the imports to be checked
    * @return `true` if an error was generated
    * @see CompileTimeErrorCode#SHARED_DEFERRED_PREFIX
    */
   bool _checkForDeferredPrefixCollisions(CompilationUnit node) {
     bool foundError = false;
     NodeList<Directive> directives = node.directives;
     int count = directives.length;
     if (count > 0) {
-      Map<PrefixElement, List<ImportDirective>> prefixToDirectivesMap = new Map<PrefixElement, List<ImportDirective>>();
+      HashMap<PrefixElement, List<ImportDirective>> prefixToDirectivesMap = new HashMap<PrefixElement, List<ImportDirective>>();
       for (int i = 0; i < count; i++) {
         Directive directive = directives[i];
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive;
           SimpleIdentifier prefix = importDirective.prefix;
           if (prefix != null) {
             Element element = prefix.staticElement;
             if (element is PrefixElement) {
               PrefixElement prefixElement = element;
               List<ImportDirective> elements = prefixToDirectivesMap[prefixElement];
@@ skipping 312 matching lines @@
     // test the static type of the expression
     DartType staticType = getStaticType(expression);
     if (staticType == null) {
       return false;
     }
     if (staticType.isAssignableTo(fieldType)) {
       return false;
     }
     // report problem
     if (_isEnclosingConstructorConst) {
-      _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType.displayName, fieldType.displayName]);
+      _errorReporter.reportTypeErrorForNode(CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType, fieldType]);
     } else {
-      _errorReporter.reportErrorForNode(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType.displayName, fieldType.displayName]);
+      _errorReporter.reportTypeErrorForNode(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType, fieldType]);
     }
     return true;
   }
 
   /**
    * This verifies that the passed field formal parameter is in a constructor declaration.
    *
    * @param node the field formal parameter to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR
@@ skipping 120 matching lines @@
   /**
    * This verifies that if the passed identifier is part of constructor initializer, then it does
    * not reference implicitly 'this' expression.
    *
    * @param node the simple identifier to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPLICIT_THIS_REFERENCE_IN_INITIALIZER
    * @see CompileTimeErrorCode#INSTANCE_MEMBER_ACCESS_FROM_STATIC TODO(scheglov) rename thid method
    */
   bool _checkForImplicitThisReferenceInInitializer(SimpleIdentifier node) {
-    if (!_isInConstructorInitializer && !_isInStaticMethod && !_isInInstanceVariableInitializer && !_isInStaticVariableDeclaration) {
+    if (!_isInConstructorInitializer && !_isInStaticMethod && !_isInFactory && !_isInInstanceVariableInitializer && !_isInStaticVariableDeclaration) {
       return false;
     }
     // prepare element
     Element element = node.staticElement;
     if (!(element is MethodElement || element is PropertyAccessorElement)) {
       return false;
     }
     // static element
     ExecutableElement executableElement = element as ExecutableElement;
     if (executableElement.isStatic) {
@@ skipping 25 matching lines @@
     }
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent;
       if (identical(prefixed.identifier, node)) {
         return false;
       }
     }
     // report problem
     if (_isInStaticMethod) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC, node, []);
+    } else if (_isInFactory) {
+      _errorReporter.reportErrorForNode(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, node, []);
     } else {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER, node, []);
     }
     return true;
   }
 
   /**
    * This verifies the passed import has unique name among other imported libraries.
    *
    * @param node the import directive to evaluate
@@ skipping 109 matching lines @@
     // OK, instance member
     if (!executableElement.isStatic) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER, name, [name.name]);
     return true;
   }
 
   /**
+   * This checks whether the given [executableElement] collides with the name of a static
+   * method in one of its superclasses, and reports the appropriate warning if it does.
+   *
+   * @param executableElement the method to check.
+   * @param errorNameTarget the node to report problems on.
+   * @return `true` if and only if a warning was generated.
+   * @see StaticTypeWarningCode#INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC
+   */
+  bool _checkForInstanceMethodNameCollidesWithSuperclassStatic(ExecutableElement executableElement, SimpleIdentifier errorNameTarget) {
+    String executableElementName = executableElement.name;
+    if (executableElement is! PropertyAccessorElement && !executableElement.isOperator) {
+      Set<ClassElement> visitedClasses = new Set<ClassElement>();
+      InterfaceType superclassType = _enclosingClass.supertype;
+      ClassElement superclassElement = superclassType == null ? null : superclassType.element;
+      bool executableElementPrivate = Identifier.isPrivateName(executableElementName);
+      while (superclassElement != null && !visitedClasses.contains(superclassElement)) {
+        visitedClasses.add(superclassElement);
+        LibraryElement superclassLibrary = superclassElement.library;
+        // Check fields.
+        List<FieldElement> fieldElts = superclassElement.fields;
+        for (FieldElement fieldElt in fieldElts) {
+          // We need the same name.
+          if (fieldElt.name != executableElementName) {
+            continue;
+          }
+          // Ignore if private in a different library - cannot collide.
+          if (executableElementPrivate && _currentLibrary != superclassLibrary) {
+            continue;
+          }
+          // instance vs. static
+          if (fieldElt.isStatic) {
+            _errorReporter.reportErrorForNode(StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC, errorNameTarget, [
+                executableElementName,
+                fieldElt.enclosingElement.displayName]);
+            return true;
+          }
+        }
+        // Check methods.
+        List<MethodElement> methodElements = superclassElement.methods;
+        for (MethodElement methodElement in methodElements) {
+          // We need the same name.
+          if (methodElement.name != executableElementName) {
+            continue;
+          }
+          // Ignore if private in a different library - cannot collide.
+          if (executableElementPrivate && _currentLibrary != superclassLibrary) {
+            continue;
+          }
+          // instance vs. static
+          if (methodElement.isStatic) {
+            _errorReporter.reportErrorForNode(StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC, errorNameTarget, [
+                executableElementName,
+                methodElement.enclosingElement.displayName]);
+            return true;
+          }
+        }
+        superclassType = superclassElement.supertype;
+        superclassElement = superclassType == null ? null : superclassType.element;
+      }
+    }
+    return false;
+  }
+
+  /**
    * 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
    */
   bool _checkForIntNotAssignable(Expression argument) {
     if (argument == null) {
@@ skipping 31 matching lines @@
    * @see StaticTypeWarningCode#INVALID_ASSIGNMENT
    */
   bool _checkForInvalidAssignment(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return false;
     }
     VariableElement leftVariableElement = getVariableElement(lhs);
     DartType leftType = (leftVariableElement == null) ? getStaticType(lhs) : leftVariableElement.type;
     DartType staticRightType = getStaticType(rhs);
     if (!staticRightType.isAssignableTo(leftType)) {
-      String leftName = leftType.displayName;
-      String rightName = staticRightType.displayName;
-      if (leftName == rightName) {
-        Element leftElement = leftType.element;
-        Element rightElement = staticRightType.element;
-        if (leftElement != null && rightElement != null) {
-          leftName = leftElement.extendedDisplayName;
-          rightName = rightElement.extendedDisplayName;
-        }
-      }
-      _errorReporter.reportErrorForNode(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [rightName, leftName]);
+      _errorReporter.reportTypeErrorForNode(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [staticRightType, leftType]);
       return true;
     }
     return false;
   }
 
   /**
    * Given an assignment using a compound assignment operator, this verifies that the given
    * assignment is valid.
    *
    * @param node the assignment expression being tested
@@ skipping 10 matching lines @@
     DartType leftType = (leftVariableElement == null) ? getStaticType(lhs) : leftVariableElement.type;
     MethodElement invokedMethod = node.staticElement;
     if (invokedMethod == null) {
       return false;
     }
     DartType rightType = invokedMethod.type.returnType;
     if (leftType == null || rightType == null) {
       return false;
     }
     if (!rightType.isAssignableTo(leftType)) {
-      String leftName = leftType.displayName;
-      String rightName = rightType.displayName;
-      if (leftName == rightName) {
-        Element leftElement = leftType.element;
-        Element rightElement = rightType.element;
-        if (leftElement != null && rightElement != null) {
-          leftName = leftElement.extendedDisplayName;
-          rightName = rightElement.extendedDisplayName;
-        }
-      }
-      _errorReporter.reportErrorForNode(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [rightName, leftName]);
+      _errorReporter.reportTypeErrorForNode(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [rightType, leftType]);
       return true;
     }
     return false;
   }
 
   /**
    * Check the given initializer to ensure that the field being initialized is a valid field.
    *
    * @param node the field initializer being checked
    * @param fieldName the field name from the [ConstructorFieldInitializer]
@@ skipping 209 matching lines @@
       getterType = _getGetterType(propertyAccessorElement);
       setterType = _getSetterType(counterpartAccessor);
     } else if (propertyAccessorElement.isSetter) {
       setterType = _getSetterType(propertyAccessorElement);
       getterType = _getGetterType(counterpartAccessor);
     }
     // If either types are not assignable to each other, report an error (if the getter is null,
     // it is dynamic which is assignable to everything).
     if (setterType != null && getterType != null && !getterType.isAssignableTo(setterType)) {
       if (enclosingClassForCounterpart == null) {
-        _errorReporter.reportErrorForNode(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES, accessorDeclaration, [
-            accessorTextName,
-            setterType.displayName,
-            getterType.displayName]);
+        _errorReporter.reportTypeErrorForNode(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES, accessorDeclaration, [accessorTextName, setterType, getterType]);
         return true;
       } else {
-        _errorReporter.reportErrorForNode(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, accessorDeclaration, [
+        _errorReporter.reportTypeErrorForNode(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, accessorDeclaration, [
             accessorTextName,
-            setterType.displayName,
-            getterType.displayName,
+            setterType,
+            getterType,
             enclosingClassForCounterpart.displayName]);
       }
     }
     return false;
   }
 
   /**
    * This verifies that the given function body does not contain return statements that both have
    * and do not have return values.
    *
@@ skipping 719 matching lines @@
    * @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, DartType expectedReturnType) {
     DartType staticReturnType = getStaticType(returnExpression);
     if (expectedReturnType.isVoid) {
       if (staticReturnType.isVoid || staticReturnType.isDynamic || staticReturnType.isBottom) {
         return false;
       }
-      _errorReporter.reportErrorForNode(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
-          staticReturnType.displayName,
-          expectedReturnType.displayName,
+      _errorReporter.reportTypeErrorForNode(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
+          staticReturnType,
+          expectedReturnType,
           _enclosingFunction.displayName]);
       return true;
     }
     bool isStaticAssignable = staticReturnType.isAssignableTo(expectedReturnType);
     if (isStaticAssignable) {
       return false;
     }
-    _errorReporter.reportErrorForNode(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
-        staticReturnType.displayName,
-        expectedReturnType.displayName,
+    _errorReporter.reportTypeErrorForNode(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
+        staticReturnType,
+        expectedReturnType,
         _enclosingFunction.displayName]);
     return true;
   }
 
   /**
    * This checks the given "typeReference" and that the "name" is not the reference to an instance
    * member.
    *
    * @param typeReference the resolved [ClassElement] of the left hand side of the expression,
    *          or `null`, aka, the class element of 'C' in 'C.x', see
@@ skipping 126 matching lines @@
         if (typeArguments.length != 0 && typeArguments.length == typeParameters.length) {
           boundType = boundType.substitute2(typeArguments, typeParameters);
         }
         if (!argType.isSubtypeOf(boundType)) {
           ErrorCode errorCode;
           if (_isInConstInstanceCreation) {
             errorCode = CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS;
           } else {
             errorCode = StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS;
           }
-          _errorReporter.reportErrorForNode(errorCode, argTypeName, [argType.displayName, boundType.displayName]);
+          _errorReporter.reportTypeErrorForNode(errorCode, argTypeName, [argType, boundType]);
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
    * This checks that if the passed type name is a type parameter being used to define a static
    * member.
@@ skipping 134 matching lines @@
         ParameterElement parameterElement = node.element;
         if (parameterElement is FieldFormalParameterElementImpl) {
           FieldFormalParameterElementImpl fieldFormal = parameterElement;
           DartType declaredType = fieldFormal.type;
           DartType fieldType = fieldElement.type;
           if (fieldElement.isSynthetic) {
             _errorReporter.reportErrorForNode(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [node.identifier.name]);
           } else if (fieldElement.isStatic) {
             _errorReporter.reportErrorForNode(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [node.identifier.name]);
           } else if (declaredType != null && fieldType != null && !declaredType.isAssignableTo(fieldType)) {
-            _errorReporter.reportErrorForNode(StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE, node, [declaredType.displayName, fieldType.displayName]);
+            _errorReporter.reportTypeErrorForNode(StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE, node, [declaredType, fieldType]);
           }
         } else {
           if (fieldElement.isSynthetic) {
             _errorReporter.reportErrorForNode(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [node.identifier.name]);
           } else if (fieldElement.isStatic) {
             _errorReporter.reportErrorForNode(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [node.identifier.name]);
           }
         }
       }
     }
@@ skipping 1456 matching lines @@
    * This is a map between the set of [LibraryElement]s that the current library imports, and
    * a list of [ImportDirective]s that imports the library. In cases where the current library
    * imports a library with a single directive (such as `import lib1.dart;`), the library
    * element will map to a list of one [ImportDirective], which will then be removed from the
    * [unusedImports] list. In cases where the current library imports a library with multiple
    * directives (such as `import lib1.dart; import lib1.dart show C;`), the
    * [LibraryElement] will be mapped to a list of the import directives, and the namespace
    * will need to be used to compute the correct [ImportDirective] being used, see
    * [namespaceMap].
    */
-  Map<LibraryElement, List<ImportDirective>> _libraryMap;
+  HashMap<LibraryElement, List<ImportDirective>> _libraryMap;
 
   /**
    * In cases where there is more than one import directive per library element, this mapping is
    * used to determine which of the multiple import directives are used by generating a
    * [Namespace] for each of the imports to do lookups in the same way that they are done from
    * the [ElementResolver].
    */
-  Map<ImportDirective, Namespace> _namespaceMap;
+  HashMap<ImportDirective, Namespace> _namespaceMap;
 
   /**
    * This is a map between prefix elements and the import directives from which they are derived. In
    * cases where a type is referenced via a prefix element, the import directive can be marked as
    * used (removed from the unusedImports) by looking at the resolved `lib` in `lib.X`,
    * instead of looking at which library the `lib.X` resolves.
    *
    * TODO (jwren) Since multiple [ImportDirective]s can share the same [PrefixElement],
    * it is possible to have an unreported unused import in situations where two imports use the same
    * prefix and at least one import directive is used.
    */
-  Map<PrefixElement, List<ImportDirective>> _prefixElementMap;
+  HashMap<PrefixElement, List<ImportDirective>> _prefixElementMap;
 
   /**
    * Create a new instance of the [ImportsVerifier].
    *
    * @param errorReporter the error reporter
    */
   ImportsVerifier(LibraryElement library) {
     this._currentLibrary = library;
     this._unusedImports = new List<ImportDirective>();
     this._duplicateImports = new List<ImportDirective>();
-    this._libraryMap = new Map<LibraryElement, List<ImportDirective>>();
-    this._namespaceMap = new Map<ImportDirective, Namespace>();
-    this._prefixElementMap = new Map<PrefixElement, List<ImportDirective>>();
+    this._libraryMap = new HashMap<LibraryElement, List<ImportDirective>>();
+    this._namespaceMap = new HashMap<ImportDirective, Namespace>();
+    this._prefixElementMap = new HashMap<PrefixElement, List<ImportDirective>>();
   }
 
   /**
    * Any time after the defining compilation unit has been visited by this visitor, this method can
    * be called to report an [HintCode#DUPLICATE_IMPORT] hint for each of the import directives
    * in the [duplicateImports] list.
    *
    * @param errorReporter the error reporter to report the set of [HintCode#DUPLICATE_IMPORT]
    *          hints to
    */
@@ skipping 116 matching lines @@
     if (_unusedImports.isEmpty) {
       return null;
     }
     // If the prefixed identifier references some A.B, where A is a library prefix, then we can
     // lookup the associated ImportDirective in prefixElementMap and remove it from the
     // unusedImports list.
     SimpleIdentifier prefixIdentifier = node.prefix;
     Element element = prefixIdentifier.staticElement;
     if (element is PrefixElement) {
       List<ImportDirective> importDirectives = _prefixElementMap[element];
-      for (ImportDirective importDirective in importDirectives) {
-        _unusedImports.remove(importDirective);
+      if (importDirectives != null) {
+        for (ImportDirective importDirective in importDirectives) {
+          _unusedImports.remove(importDirective);
+        }
       }
       return null;
     }
     // Otherwise, pass the prefixed identifier element and name onto visitIdentifier.
     return _visitIdentifier(element, prefixIdentifier.name);
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (_unusedImports.isEmpty) {
@@ skipping 54 matching lines @@
       importList = new List<ImportDirective>();
       _libraryMap[libraryElement] = importList;
     }
     importList.add(importDirective);
   }
 
   Object _visitIdentifier(Element element, String name) {
     if (element == null) {
       return null;
     }
-    // If the element is multiply defined then call this method recursively for each of the conflicting elements.
+    // If the element is multiply defined then call this method recursively for each of the
+    // conflicting elements.
     if (element is MultiplyDefinedElement) {
       MultiplyDefinedElement multiplyDefinedElement = element;
       for (Element elt in multiplyDefinedElement.conflictingElements) {
         _visitIdentifier(elt, name);
       }
       return null;
     } else if (element is PrefixElement) {
       List<ImportDirective> importDirectives = _prefixElementMap[element];
-      for (ImportDirective importDirective in importDirectives) {
-        _unusedImports.remove(importDirective);
+      if (importDirectives != null) {
+        for (ImportDirective importDirective in importDirectives) {
+          _unusedImports.remove(importDirective);
+        }
       }
       return null;
     } else if (element.enclosingElement is! CompilationUnitElement) {
       // Identifiers that aren't a prefix element and whose enclosing element isn't a
       // CompilationUnit are ignored- this covers the case the identifier is a relative-reference,
       // a reference to an identifier not imported by this library.
       return null;
     }
     LibraryElement containingLibrary = element.library;
     if (containingLibrary == null) {
@@ skipping 182 matching lines @@
   /**
    * Given some array of [ExecutableElement]s, this method creates a synthetic element as
    * described in 8.1.1:
    *
    * Let <i>numberOfPositionals</i>(<i>f</i>) denote the number of positional parameters of a
    * function <i>f</i>, and let <i>numberOfRequiredParams</i>(<i>f</i>) denote the number of
    * required parameters of a function <i>f</i>. Furthermore, let <i>s</i> denote the set of all
    * named parameters of the <i>m<sub>1</sub>, &hellip;, m<sub>k</sub></i>. Then let
    * * <i>h = max(numberOfPositionals(m<sub>i</sub>)),</i>
    * * <i>r = min(numberOfRequiredParams(m<sub>i</sub>)), for all <i>i</i>, 1 <= i <= k.</i>
-   * If <i>r <= h</i> then <i>I</i> has a method named <i>n</i>, with <i>r</i> required parameters
-   * of type <b>dynamic</b>, <i>h</i> positional parameters of type <b>dynamic</b>, named parameters
+   * Then <i>I</i> has a method named <i>n</i>, with <i>r</i> required parameters of type
+   * <b>dynamic</b>, <i>h</i> positional parameters of type <b>dynamic</b>, named parameters
    * <i>s</i> of type <b>dynamic</b> and return type <b>dynamic</b>.
    *
    * TODO (jwren) Associate a propagated type to the synthetic method element using least upper
    * bounds instead of dynamic
    */
   static ExecutableElement _computeMergedExecutableElement(List<ExecutableElement> elementArrayToMerge) {
     int h = _getNumOfPositionalParameters(elementArrayToMerge[0]);
     int r = _getNumOfRequiredParameters(elementArrayToMerge[0]);
     Set<String> namedParametersList = new Set<String>();
     for (int i = 1; i < elementArrayToMerge.length; i++) {
       ExecutableElement element = elementArrayToMerge[i];
       int numOfPositionalParams = _getNumOfPositionalParameters(element);
       if (h < numOfPositionalParams) {
         h = numOfPositionalParams;
       }
       int numOfRequiredParams = _getNumOfRequiredParameters(element);
       if (r > numOfRequiredParams) {
         r = numOfRequiredParams;
       }
       namedParametersList.addAll(_getNamedParameterNames(element));
     }
-    if (r > h) {
-      return null;
-    }
     return _createSyntheticExecutableElement(elementArrayToMerge, elementArrayToMerge[0].displayName, r, h - r, new List.from(namedParametersList));
   }
 
   /**
    * Used by [computeMergedExecutableElement] to actually create the
    * synthetic element.
    *
    * @param elementArrayToMerge the array used to create the synthetic element
    * @param name the name of the method, getter or setter
    * @param numOfRequiredParameters the number of required parameters
@@ skipping 104 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, MemberMap> _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, MemberMap> _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 Map<ClassElement, Set<AnalysisError>>();
+  HashMap<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 Map<ClassElement, MemberMap>();
-    _interfaceLookup = new Map<ClassElement, MemberMap>();
+    _classLookup = new HashMap<ClassElement, MemberMap>();
+    _interfaceLookup = new HashMap<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
    */
@@ skipping 72 matching lines @@
    */
   FunctionType lookupMemberType(InterfaceType interfaceType, String memberName) {
     ExecutableElement iteratorMember = lookupMember(interfaceType.element, memberName);
     if (iteratorMember == null) {
       return null;
     }
     return substituteTypeArgumentsInMemberFromInheritance(iteratorMember.type, memberName, interfaceType);
   }
 
   /**
+   * Determine the set of methods which is overridden by the given class member. If no member is
+   * inherited, an empty list is returned. If one of the inherited members is a
+   * [MultiplyInheritedExecutableElement], then it is expanded into its constituent inherited
+   * elements.
+   *
+   * @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 = _gatherInterfaceLookupMaps(classElt, new Set<ClassElement>());
+    if (interfaceMaps != null) {
+      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);
+          }
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
    * Set the new library element context.
    *
    * @param library the new library element
    */
   void set libraryElement(LibraryElement library) {
     this._library = library;
   }
 
   /**
    * This method takes some inherited [FunctionType], and resolves all the parameterized types
@@ skipping 192 matching lines @@
    * @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(ClassElement classElt, Set<ClassElement> visitedInterfaces) {
     MemberMap resultMap = _interfaceLookup[classElt];
     if (resultMap != null) {
       return resultMap;
+    }
+    List<MemberMap> lookupMaps = _gatherInterfaceLookupMaps(classElt, visitedInterfaces);
+    if (lookupMaps == null) {
+      resultMap = new MemberMap();
     } else {
-      resultMap = new MemberMap();
+      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(ClassElement classElt, Set<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>();
     //
     // Superclass element
     //
     if (superclassElement != null) {
@@ skipping 11 matching lines @@
           _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 {
-        MemberMap map = _interfaceLookup[classElt];
-        if (map != null) {
-          lookupMaps.add(map);
-        } else {
-          _interfaceLookup[superclassElement] = resultMap;
-          return resultMap;
-        }
+        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)) {
@@ skipping 10 matching lines @@
             _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 {
-          MemberMap map = _interfaceLookup[classElt];
-          if (map != null) {
-            lookupMaps.add(map);
-          } else {
-            _interfaceLookup[mixinElement] = resultMap;
-            return resultMap;
-          }
+          return null;
         }
       }
     }
     //
     // Interface elements
     //
     for (InterfaceType interfaceType in interfaces) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
         if (!visitedInterfaces.contains(interfaceElement)) {
@@ skipping 10 matching lines @@
             _substituteTypeParametersDownHierarchy(interfaceType, map);
             //
             // And add any members from the interface into the map as well.
             //
             _recordMapWithClassMembers(map, interfaceType, true);
             lookupMaps.add(map);
           } finally {
             visitedInterfaces.remove(interfaceElement);
           }
         } else {
-          MemberMap map = _interfaceLookup[classElt];
-          if (map != null) {
-            lookupMaps.add(map);
-          } else {
-            _interfaceLookup[interfaceElement] = resultMap;
-            return resultMap;
-          }
+          return null;
         }
       }
     }
     if (lookupMaps.length == 0) {
-      _interfaceLookup[classElt] = resultMap;
-      return resultMap;
+      return null;
     }
-    //
-    // Union all of the lookupMaps together into unionMap, 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.)
-    //
-    Map<String, List<ExecutableElement>> unionMap = new Map<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;
-        }
-        // Get the list value out of the unionMap
-        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[key] = list;
-        }
-        // Fetch the entry out of this lookupMap
-        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) {
-            bool isMethod2 = executableElementInList is MethodElement;
-            if (isMethod1 == isMethod2 && executableElementInList.type == newExecutableElementEntry.type) {
-              alreadyInList = true;
-              break;
-            }
-          }
-          if (!alreadyInList) {
-            list.add(newExecutableElementEntry);
-          }
-        }
+    return lookupMaps;
+  }
+
+  /**
+   * Given some [ClassElement], this method finds and returns the [ExecutableElement] of
+   * the passed name in the class element. Static members, members in super types and members not
+   * accessible from the current library are not considered.
+   *
+   * @param classElt the class element to query
+   * @param memberName the name of the member to lookup in the class
+   * @return the found [ExecutableElement], or `null` if no such member was found
+   */
+  ExecutableElement _lookupMemberInClass(ClassElement classElt, String memberName) {
+    List<MethodElement> methods = classElt.methods;
+    for (MethodElement method in methods) {
+      if (memberName == method.name && method.isAccessibleIn(_library) && !method.isStatic) {
+        return method;
       }
     }
-    //
-    // Loop through the entries in the unionMap, adding them to the resultMap appropriately.
-    //
+    List<PropertyAccessorElement> accessors = classElt.accessors;
+    for (PropertyAccessorElement accessor in accessors) {
+      if (memberName == accessor.name && accessor.isAccessibleIn(_library) && !accessor.isStatic) {
+        return accessor;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 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) {
+    List<MethodElement> methods = type.methods;
+    for (MethodElement method in methods) {
+      if (method.isAccessibleIn(_library) && !method.isStatic && (doIncludeAbstract || !method.isAbstract)) {
+        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.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
+   * @param offset the offset of the location of the error
+   * @param length the length of the location of the error
+   * @param errorCode the error code to be associated with this error
+   * @param arguments the arguments used to build the error message
+   */
+  void _reportError(ClassElement classElt, int offset, int length, ErrorCode errorCode, List<Object> arguments) {
+    Set<AnalysisError> errorSet = _errorsInClassElement[classElt];
+    if (errorSet == null) {
+      errorSet = new Set<AnalysisError>();
+      _errorsInClassElement[classElt] = errorSet;
+    }
+    errorSet.add(new AnalysisError.con2(classElt.source, offset, length, errorCode, arguments));
+  }
+
+  /**
+   * Given the set of methods defined by classes above [classElt] in the class hierarchy,
+   * 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();
     for (MapEntry<String, List<ExecutableElement>> entry in getMapEntrySet(unionMap)) {
       String key = entry.getKey();
       List<ExecutableElement> list = entry.getValue();
       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.
@@ skipping 95 matching lines @@
               // '(int) -> dynamic' and one has the function type '(num) -> dynamic'. Since they are
               // both a subtype of the other, a synthetic function '(dynamic) -> dynamic' is
               // inherited.
               // Tests: test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_*
               //
               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);
-              if (mergedExecutableElement != null) {
-                resultMap.put(key, mergedExecutableElement);
-              }
+              resultMap.put(key, mergedExecutableElement);
             }
           }
         } else {
           _reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD, [key]);
         }
       }
     }
-    _interfaceLookup[classElt] = resultMap;
     return resultMap;
   }
 
   /**
-   * Given some [ClassElement], this method finds and returns the [ExecutableElement] of
-   * the passed name in the class element. Static members, members in super types and members not
-   * accessible from the current library are not considered.
-   *
-   * @param classElt the class element to query
-   * @param memberName the name of the member to lookup in the class
-   * @return the found [ExecutableElement], or `null` if no such member was found
-   */
-  ExecutableElement _lookupMemberInClass(ClassElement classElt, String memberName) {
-    List<MethodElement> methods = classElt.methods;
-    for (MethodElement method in methods) {
-      if (memberName == method.name && method.isAccessibleIn(_library) && !method.isStatic) {
-        return method;
-      }
-    }
-    List<PropertyAccessorElement> accessors = classElt.accessors;
-    for (PropertyAccessorElement accessor in accessors) {
-      if (memberName == accessor.name && accessor.isAccessibleIn(_library) && !accessor.isStatic) {
-        return accessor;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * 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) {
-    List<MethodElement> methods = type.methods;
-    for (MethodElement method in methods) {
-      if (method.isAccessibleIn(_library) && !method.isStatic && (doIncludeAbstract || !method.isAbstract)) {
-        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.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
-   * @param offset the offset of the location of the error
-   * @param length the length of the location of the error
-   * @param errorCode the error code to be associated with this error
-   * @param arguments the arguments used to build the error message
-   */
-  void _reportError(ClassElement classElt, int offset, int length, ErrorCode errorCode, List<Object> arguments) {
-    Set<AnalysisError> errorSet = _errorsInClassElement[classElt];
-    if (errorSet == null) {
-      errorSet = new Set<AnalysisError>();
-      _errorsInClassElement[classElt] = errorSet;
-    }
-    errorSet.add(new AnalysisError.con2(classElt.source, offset, length, errorCode, arguments));
-  }
-
-  /**
    * 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, 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.setValue(i, executableElement);
       } else if (executableElement is PropertyAccessorMember) {
         executableElement = PropertyAccessorMember.from(executableElement as PropertyAccessorMember, superType);
         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.
+   */
+  HashMap<String, List<ExecutableElement>> _unionInterfaceLookupMaps(List<MemberMap> 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;
+        }
+        // Get the list value out of the unionMap
+        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[key] = list;
+        }
+        // Fetch the entry out of this lookupMap
+        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) {
+            bool isMethod2 = executableElementInList is MethodElement;
+            if (isMethod1 == isMethod2 && executableElementInList.type == newExecutableElementEntry.type) {
+              alreadyInList = true;
+              break;
+            }
+          }
+          if (!alreadyInList) {
+            list.add(newExecutableElementEntry);
+          }
+        }
+      }
+    }
+    return unionMap;
+  }
 }
 
 /**
  * Instances of the class `LabelScope` represent a scope in which a single label is defined.
  */
 class LabelScope {
   /**
    * The label scope enclosing this label scope.
    */
   final LabelScope _outerScope;
@@ skipping 89 matching lines @@
   LibraryElementImpl _libraryElement;
 
   /**
    * A list containing all of the libraries that are imported into this library.
    */
   List<Library> _importedLibraries = _EMPTY_ARRAY;
 
   /**
    * A table mapping URI-based directive to the actual URI value.
    */
-  Map<UriBasedDirective, String> _directiveUris = new Map<UriBasedDirective, String>();
+  HashMap<UriBasedDirective, String> _directiveUris = new HashMap<UriBasedDirective, String>();
 
   /**
    * A flag indicating whether this library explicitly imports core.
    */
   bool explicitlyImportsCore = false;
 
   /**
    * A list containing all of the libraries that are exported from this library.
    */
   List<Library> _exportedLibraries = _EMPTY_ARRAY;
 
   /**
    * A table mapping the sources for the compilation units in this library to their corresponding
    * AST structures.
    */
-  Map<Source, ResolvableCompilationUnit> _astMap = new Map<Source, ResolvableCompilationUnit>();
+  HashMap<Source, ResolvableCompilationUnit> _astMap = new HashMap<Source, ResolvableCompilationUnit>();
 
   /**
    * The library scope used when resolving elements within this library's compilation units.
    */
   LibraryScope _libraryScope;
 
   /**
    * An empty array that can be used to initialize lists of libraries.
    */
   static List<Library> _EMPTY_ARRAY = new List<Library>(0);
@@ skipping 431 matching lines @@
   }
 
   /**
    * Add all of the non-synthetic getters and setters defined in the given compilation unit that
    * have no corresponding accessor to one of the given collections.
    *
    * @param getters the map to which getters are to be added
    * @param setters the list to which setters are to be added
    * @param unit the compilation unit defining the accessors that are potentially being added
    */
-  void _collectAccessors(Map<String, PropertyAccessorElement> getters, List<PropertyAccessorElement> setters, CompilationUnitElement unit) {
+  void _collectAccessors(HashMap<String, PropertyAccessorElement> getters, List<PropertyAccessorElement> setters, CompilationUnitElement unit) {
     for (PropertyAccessorElement accessor in unit.accessors) {
       if (accessor.isGetter) {
         if (!accessor.isSynthetic && accessor.correspondingSetter == null) {
           getters[accessor.displayName] = accessor;
         }
       } else {
         if (!accessor.isSynthetic && accessor.correspondingGetter == null) {
           setters.add(accessor);
         }
       }
@@ skipping 40 matching lines @@
   }
 
   /**
    * Look through all of the compilation units defined for the given library, looking for getters
    * and setters that are defined in different compilation units but that have the same names. If
    * any are found, make sure that they have the same variable element.
    *
    * @param libraryElement the library defining the compilation units to be processed
    */
   void _patchTopLevelAccessors(LibraryElementImpl libraryElement) {
-    Map<String, PropertyAccessorElement> getters = new Map<String, PropertyAccessorElement>();
+    HashMap<String, PropertyAccessorElement> getters = new HashMap<String, PropertyAccessorElement>();
     List<PropertyAccessorElement> setters = new List<PropertyAccessorElement>();
     _collectAccessors(getters, setters, libraryElement.definingCompilationUnit);
     for (CompilationUnitElement unit in libraryElement.parts) {
       _collectAccessors(getters, setters, unit);
     }
     for (PropertyAccessorElement setter in setters) {
       PropertyAccessorElement getter = getters[setter.displayName];
       if (getter != null) {
         PropertyInducingElementImpl variable = getter.variable as PropertyInducingElementImpl;
         variable.setter = setter;
@@ skipping 188 matching lines @@
   Library _coreLibrary;
 
   /**
    * The object used to access the types from the core library.
    */
   TypeProvider _typeProvider;
 
   /**
    * A table mapping library sources to the information being maintained for those libraries.
    */
-  Map<Source, Library> _libraryMap = new Map<Source, Library>();
+  HashMap<Source, Library> _libraryMap = new HashMap<Source, Library>();
 
   /**
    * A collection containing the libraries that are being resolved together.
    */
   Set<Library> _librariesInCycles;
 
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    *
    * @param analysisContext the analysis context in which the library is being analyzed
@@ skipping 37 matching lines @@
       instrumentation.data3("fullName", librarySource.fullName);
       //
       // Create the objects representing the library being resolved and the core library.
       //
       Library targetLibrary = _createLibraryWithUnit(librarySource, modificationStamp, unit);
       _coreLibrary = _libraryMap[_coreLibrarySource];
       if (_coreLibrary == null) {
         // This will be true unless the library being analyzed is the core library.
         _coreLibrary = createLibrary(_coreLibrarySource);
         if (_coreLibrary == null) {
-          throw new AnalysisException("Core library does not exist");
+          LibraryResolver2.missingCoreLibrary(analysisContext, _coreLibrarySource);
         }
       }
       instrumentation.metric3("createLibrary", "complete");
       //
       // Compute the set of libraries that need to be resolved together.
       //
       _computeEmbeddedLibraryDependencies(targetLibrary, unit);
       _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
       //
       // Build the element models representing the libraries being resolved. This is done in three
@@ skipping 63 matching lines @@
       instrumentation.data3("fullName", librarySource.fullName);
       //
       // Create the objects representing the library being resolved and the core library.
       //
       Library targetLibrary = createLibrary(librarySource);
       _coreLibrary = _libraryMap[_coreLibrarySource];
       if (_coreLibrary == null) {
         // This will be true unless the library being analyzed is the core library.
         _coreLibrary = _createLibraryOrNull(_coreLibrarySource);
         if (_coreLibrary == null) {
-          throw new AnalysisException("Core library does not exist");
+          LibraryResolver2.missingCoreLibrary(analysisContext, _coreLibrarySource);
         }
       }
       instrumentation.metric3("createLibrary", "complete");
       //
       // Compute the set of libraries that need to be resolved together.
       //
       _computeLibraryDependencies(targetLibrary);
       _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
       //
       // Build the element models representing the libraries being resolved. This is done in three
@@ skipping 61 matching lines @@
     return library;
   }
 
   /**
    * Add a dependency to the given map from the referencing library to the referenced library.
    *
    * @param dependencyMap the map to which the dependency is to be added
    * @param referencingLibrary the library that references the referenced library
    * @param referencedLibrary the library referenced by the referencing library
    */
-  void _addDependencyToMap(Map<Library, List<Library>> dependencyMap, Library referencingLibrary, Library referencedLibrary) {
+  void _addDependencyToMap(HashMap<Library, List<Library>> dependencyMap, Library referencingLibrary, Library referencedLibrary) {
     List<Library> dependentLibraries = dependencyMap[referencedLibrary];
     if (dependentLibraries == null) {
       dependentLibraries = new List<Library>();
       dependencyMap[referencedLibrary] = dependentLibraries;
     }
     dependentLibraries.add(referencingLibrary);
   }
 
   /**
    * Given a library that is part of a cycle that includes the root library, add to the given set of
    * libraries all of the libraries reachable from the root library that are also included in the
    * cycle.
    *
    * @param library the library to be added to the collection of libraries in cycles
    * @param librariesInCycle a collection of the libraries that are in the cycle
    * @param dependencyMap a table mapping libraries to the collection of libraries from which those
    *          libraries are referenced
    */
-  void _addLibrariesInCycle(Library library, Set<Library> librariesInCycle, Map<Library, List<Library>> dependencyMap) {
+  void _addLibrariesInCycle(Library library, Set<Library> librariesInCycle, HashMap<Library, List<Library>> dependencyMap) {
     if (librariesInCycle.add(library)) {
       List<Library> dependentLibraries = dependencyMap[library];
       if (dependentLibraries != null) {
         for (Library dependentLibrary in dependentLibraries) {
           _addLibrariesInCycle(dependentLibrary, librariesInCycle, dependencyMap);
         }
       }
     }
   }
 
   /**
    * Add the given library, and all libraries reachable from it that have not already been visited,
    * to the given dependency map.
    *
    * @param library the library currently being added to the dependency map
    * @param dependencyMap the dependency map being computed
    * @param visitedLibraries the libraries that have already been visited, used to prevent infinite
    *          recursion
    */
-  void _addToDependencyMap(Library library, Map<Library, List<Library>> dependencyMap, Set<Library> visitedLibraries) {
+  void _addToDependencyMap(Library library, HashMap<Library, List<Library>> dependencyMap, Set<Library> visitedLibraries) {
     if (visitedLibraries.add(library)) {
       for (Library referencedLibrary in library.importsAndExports) {
         _addDependencyToMap(dependencyMap, library, referencedLibrary);
         _addToDependencyMap(referencedLibrary, dependencyMap, visitedLibraries);
       }
       if (!library.explicitlyImportsCore && !identical(library, _coreLibrary)) {
         _addDependencyToMap(dependencyMap, library, _coreLibrary);
       }
     }
   }
@@ skipping 24 matching lines @@
 
   /**
    * Every library now has a corresponding [LibraryElement], so it is now possible to resolve
    * the import and export directives.
    *
    * @throws AnalysisException if the defining compilation unit for any of the libraries could not
    *           be accessed
    */
   void _buildDirectiveModels() {
     for (Library library in _librariesInCycles) {
-      Map<String, PrefixElementImpl> nameToPrefixMap = new Map<String, PrefixElementImpl>();
+      HashMap<String, PrefixElementImpl> nameToPrefixMap = new HashMap<String, PrefixElementImpl>();
       List<ImportElement> imports = new List<ImportElement>();
       List<ExportElement> exports = new List<ExportElement>();
       for (Directive directive in library.definingCompilationUnit.directives) {
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive;
           String uriContent = importDirective.uriContent;
           if (DartUriResolver.isDartExtUri(uriContent)) {
             library.libraryElement.hasExtUri = true;
           }
           Source importedSource = importDirective.source;
@@ skipping 115 matching lines @@
    * Compute a dependency map of libraries reachable from the given library. A dependency map is a
    * table that maps individual libraries to a list of the libraries that either import or export
    * those libraries.
    *
    * This map is used to compute all of the libraries involved in a cycle that include the root
    * library. Given that we only add libraries that are reachable from the root library, when we
    * work backward we are guaranteed to only get libraries in the cycle.
    *
    * @param library the library currently being added to the dependency map
    */
-  Map<Library, List<Library>> _computeDependencyMap(Library library) {
-    Map<Library, List<Library>> dependencyMap = new Map<Library, List<Library>>();
+  HashMap<Library, List<Library>> _computeDependencyMap(Library library) {
+    HashMap<Library, List<Library>> dependencyMap = new HashMap<Library, List<Library>>();
     _addToDependencyMap(library, dependencyMap, new Set<Library>());
     return dependencyMap;
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
    * class [Library] to represent them, and record the references in the library objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @throws AnalysisException if some portion of the library graph could not be traversed
@@ skipping 20 matching lines @@
 
   /**
    * Return a collection containing all of the libraries reachable from the given library that are
    * contained in a cycle that includes the given library.
    *
    * @param library the library that must be included in any cycles whose members are to be returned
    * @return all of the libraries referenced by the given library that have a circular reference
    *         back to the given library
    */
   Set<Library> _computeLibrariesInCycles(Library library) {
-    Map<Library, List<Library>> dependencyMap = _computeDependencyMap(library);
+    HashMap<Library, List<Library>> dependencyMap = _computeDependencyMap(library);
     Set<Library> librariesInCycle = new Set<Library>();
     _addLibrariesInCycle(library, librariesInCycle, dependencyMap);
     return librariesInCycle;
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
    * class [Library] to represent them, and record the references in the library objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
@@ skipping 207 matching lines @@
     return analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
   }
 }
 
 /**
  * Instances of the class `LibraryResolver` are used to resolve one or more mutually dependent
  * libraries within a single context.
  */
 class LibraryResolver2 {
   /**
+   * Report that the core library could not be resolved in the given analysis context and throw an
+   * exception.
+   *
+   * @param analysisContext the analysis context in which the failure occurred
+   * @param coreLibrarySource the source representing the core library
+   * @throws AnalysisException always
+   */
+  static void missingCoreLibrary(AnalysisContext analysisContext, Source coreLibrarySource) {
+    throw new AnalysisException("Could not resolve dart:core");
+  }
+
+  /**
    * The analysis context in which the libraries are being analyzed.
    */
   final InternalAnalysisContext analysisContext;
 
   /**
    * The listener to which analysis errors will be reported, this error listener is either
    * references [recordingErrorListener], or it unions the passed
    * [AnalysisErrorListener] with the [recordingErrorListener].
    */
   RecordingErrorListener _errorListener;
 
   /**
    * A source object representing the core library (dart:core).
    */
   Source _coreLibrarySource;
 
   /**
    * The object representing the core library.
    */
   ResolvableLibrary _coreLibrary;
 
   /**
    * The object used to access the types from the core library.
    */
   TypeProvider _typeProvider;
 
   /**
    * A table mapping library sources to the information being maintained for those libraries.
    */
-  Map<Source, ResolvableLibrary> _libraryMap = new Map<Source, ResolvableLibrary>();
+  HashMap<Source, ResolvableLibrary> _libraryMap = new HashMap<Source, ResolvableLibrary>();
 
   /**
    * A collection containing the libraries that are being resolved together.
    */
   List<ResolvableLibrary> _librariesInCycle;
 
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    *
    * @param analysisContext the analysis context in which the library is being analyzed
@@ skipping 53 matching lines @@
       //    elements built for the referenced libraries, but because of the possibility of circular
       //    references needs to happen after all of the library elements have been created.
       // 3. Build the rest of the type model by connecting superclasses, mixins, and interfaces. This
       //    requires that we be able to compute the names visible in the libraries being resolved,
       //    which in turn requires that we have resolved the import directives.
       //
       _buildElementModels();
       instrumentation.metric3("buildElementModels", "complete");
       LibraryElement coreElement = _coreLibrary.libraryElement;
       if (coreElement == null) {
-        throw new AnalysisException("Could not resolve dart:core");
+        missingCoreLibrary(analysisContext, _coreLibrarySource);
       }
       _buildDirectiveModels();
       instrumentation.metric3("buildDirectiveModels", "complete");
       _typeProvider = new TypeProviderImpl(coreElement);
       _buildTypeHierarchies();
       instrumentation.metric3("buildTypeHierarchies", "complete");
       //
       // Perform resolution and type analysis.
       //
       // TODO(brianwilkerson) Decide whether we want to resolve all of the libraries or whether we
@@ skipping 46 matching lines @@
 
   /**
    * Every library now has a corresponding [LibraryElement], so it is now possible to resolve
    * the import and export directives.
    *
    * @throws AnalysisException if the defining compilation unit for any of the libraries could not
    *           be accessed
    */
   void _buildDirectiveModels() {
     for (ResolvableLibrary library in _librariesInCycle) {
-      Map<String, PrefixElementImpl> nameToPrefixMap = new Map<String, PrefixElementImpl>();
+      HashMap<String, PrefixElementImpl> nameToPrefixMap = new HashMap<String, PrefixElementImpl>();
       List<ImportElement> imports = new List<ImportElement>();
       List<ExportElement> exports = new List<ExportElement>();
       for (Directive directive in library.definingCompilationUnit.directives) {
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive;
           String uriContent = importDirective.uriContent;
           if (DartUriResolver.isDartExtUri(uriContent)) {
             library.libraryElement.hasExtUri = true;
           }
           Source importedSource = importDirective.source;
@@ skipping 88 matching lines @@
    * @throws AnalysisException if any of the element models cannot be built
    */
   void _buildElementModels() {
     for (ResolvableLibrary library in _librariesInCycle) {
       LibraryElementBuilder builder = new LibraryElementBuilder(analysisContext, errorListener);
       LibraryElementImpl libraryElement = builder.buildLibrary2(library);
       library.libraryElement = libraryElement;
     }
   }
 
-  Map<Source, ResolvableLibrary> _buildLibraryMap() {
-    Map<Source, ResolvableLibrary> libraryMap = new Map<Source, ResolvableLibrary>();
+  HashMap<Source, ResolvableLibrary> _buildLibraryMap() {
+    HashMap<Source, ResolvableLibrary> libraryMap = new HashMap<Source, ResolvableLibrary>();
     int libraryCount = _librariesInCycle.length;
     for (int i = 0; i < libraryCount; i++) {
       ResolvableLibrary library = _librariesInCycle[i];
       library.errorListener = _errorListener;
       libraryMap[library.librarySource] = library;
       List<ResolvableLibrary> dependencies = library.importsAndExports;
       int dependencyCount = dependencies.length;
       for (int j = 0; j < dependencyCount; j++) {
         ResolvableLibrary dependency = dependencies[j];
         //dependency.setErrorListener(errorListener);
@@ skipping 352 matching lines @@
 
 /**
  * Instances of the class `Namespace` implement a mapping of identifiers to the elements
  * represented by those identifiers. Namespaces are the building blocks for scopes.
  */
 class Namespace {
   /**
    * A table mapping names that are defined in this namespace to the element representing the thing
    * declared with that name.
    */
-  final Map<String, Element> _definedNames;
+  final HashMap<String, Element> _definedNames;
 
   /**
    * An empty namespace.
    */
-  static Namespace EMPTY = new Namespace(new Map<String, Element>());
+  static Namespace EMPTY = new Namespace(new HashMap<String, Element>());
 
   /**
    * Initialize a newly created namespace to have the given defined names.
    *
    * @param definedNames the mapping from names that are defined in this namespace to the
    *          corresponding elements
    */
   Namespace(this._definedNames);
 
   /**
    * Return the element in this namespace that is available to the containing scope using the given
    * name.
    *
    * @param name the name used to reference the
    * @return the element represented by the given identifier
    */
   Element get(String name) => _definedNames[name];
 
   /**
    * Return a table containing the same mappings as those defined by this namespace.
    *
    * @return a table containing the same mappings as those defined by this namespace
    */
-  Map<String, Element> get definedNames => new Map<String, Element>.from(_definedNames);
+  Map<String, Element> get definedNames => new HashMap<String, Element>.from(_definedNames);
 }
 
 /**
  * Instances of the class `NamespaceBuilder` are used to build a `Namespace`. Namespace
  * builders are thread-safe and re-usable.
  */
 class NamespaceBuilder {
   /**
    * Create a namespace representing the export namespace of the given [ExportElement].
    *
    * @param element the export element whose export namespace is to be created
    * @return the export namespace that was created
    */
   Namespace createExportNamespaceForDirective(ExportElement element) {
     LibraryElement exportedLibrary = element.exportedLibrary;
     if (exportedLibrary == null) {
       //
       // The exported library will be null if the URI does not reference a valid library.
       //
       return Namespace.EMPTY;
     }
-    Map<String, Element> definedNames = _createExportMapping(exportedLibrary, new Set<LibraryElement>());
+    HashMap<String, Element> definedNames = _createExportMapping(exportedLibrary, new Set<LibraryElement>());
     definedNames = _applyCombinators(definedNames, element.combinators);
     return new Namespace(definedNames);
   }
 
   /**
    * Create a namespace representing the export namespace of the given library.
    *
    * @param library the library whose export namespace is to be created
    * @return the export namespace that was created
    */
   Namespace createExportNamespaceForLibrary(LibraryElement library) => new Namespace(_createExportMapping(library, new Set<LibraryElement>()));
 
   /**
    * Create a namespace representing the import namespace of the given library.
    *
    * @param library the library whose import namespace is to be created
    * @return the import namespace that was created
    */
   Namespace createImportNamespaceForDirective(ImportElement element) {
     LibraryElement importedLibrary = element.importedLibrary;
     if (importedLibrary == null) {
       //
       // The imported library will be null if the URI does not reference a valid library.
       //
       return Namespace.EMPTY;
     }
-    Map<String, Element> definedNames = _createExportMapping(importedLibrary, new Set<LibraryElement>());
+    HashMap<String, Element> definedNames = _createExportMapping(importedLibrary, new Set<LibraryElement>());
     definedNames = _applyCombinators(definedNames, element.combinators);
     definedNames = _applyPrefix(definedNames, element.prefix);
     return new Namespace(definedNames);
   }
 
   /**
    * Create a namespace representing the public namespace of the given library.
    *
    * @param library the library whose public namespace is to be created
    * @return the public namespace that was created
    */
   Namespace createPublicNamespaceForLibrary(LibraryElement library) {
-    Map<String, Element> definedNames = new Map<String, Element>();
+    HashMap<String, Element> definedNames = new HashMap<String, Element>();
     _addPublicNames(definedNames, library.definingCompilationUnit);
     for (CompilationUnitElement compilationUnit in library.parts) {
       _addPublicNames(definedNames, compilationUnit);
     }
     return new Namespace(definedNames);
   }
 
   /**
    * Add all of the names in the given namespace to the given mapping table.
    *
@@ skipping 53 matching lines @@
       _addIfPublic(definedNames, element);
     }
   }
 
   /**
    * Apply the given combinators to all of the names in the given mapping table.
    *
    * @param definedNames the mapping table to which the namespace operations are to be applied
    * @param combinators the combinators to be applied
    */
-  Map<String, Element> _applyCombinators(Map<String, Element> definedNames, List<NamespaceCombinator> combinators) {
+  HashMap<String, Element> _applyCombinators(HashMap<String, Element> definedNames, List<NamespaceCombinator> combinators) {
     for (NamespaceCombinator combinator in combinators) {
       if (combinator is HideElementCombinator) {
         _hide(definedNames, combinator.hiddenNames);
       } else if (combinator is ShowElementCombinator) {
         definedNames = _show(definedNames, combinator.shownNames);
       } else {
         // Internal error.
         AnalysisEngine.instance.logger.logError("Unknown type of combinator: ${combinator.runtimeType.toString()}");
       }
     }
     return definedNames;
   }
 
   /**
    * Apply the given prefix to all of the names in the table of defined names.
    *
    * @param definedNames the names that were defined before this operation
    * @param prefixElement the element defining the prefix to be added to the names
    */
-  Map<String, Element> _applyPrefix(Map<String, Element> definedNames, PrefixElement prefixElement) {
+  HashMap<String, Element> _applyPrefix(HashMap<String, Element> definedNames, PrefixElement prefixElement) {
     if (prefixElement != null) {
       String prefix = prefixElement.name;
-      Map<String, Element> newNames = new Map<String, Element>();
+      HashMap<String, Element> newNames = new HashMap<String, Element>();
       for (MapEntry<String, Element> entry in getMapEntrySet(definedNames)) {
         newNames["${prefix}.${entry.getKey()}"] = entry.getValue();
       }
       return newNames;
     } else {
       return definedNames;
     }
   }
 
   /**
    * Create a mapping table representing the export namespace of the given library.
    *
    * @param library the library whose public namespace is to be created
    * @param visitedElements a set of libraries that do not need to be visited when processing the
    *          export directives of the given library because all of the names defined by them will
    *          be added by another library
    * @return the mapping table that was created
    */
-  Map<String, Element> _createExportMapping(LibraryElement library, Set<LibraryElement> visitedElements) {
+  HashMap<String, Element> _createExportMapping(LibraryElement library, Set<LibraryElement> visitedElements) {
     visitedElements.add(library);
     try {
-      Map<String, Element> definedNames = new Map<String, Element>();
+      HashMap<String, Element> definedNames = new HashMap<String, Element>();
       for (ExportElement element in library.exports) {
         LibraryElement exportedLibrary = element.exportedLibrary;
         if (exportedLibrary != null && !visitedElements.contains(exportedLibrary)) {
           //
           // The exported library will be null if the URI does not reference a valid library.
           //
-          Map<String, Element> exportedNames = _createExportMapping(exportedLibrary, visitedElements);
+          HashMap<String, Element> exportedNames = _createExportMapping(exportedLibrary, visitedElements);
           exportedNames = _applyCombinators(exportedNames, element.combinators);
           _addAllFromMap(definedNames, exportedNames);
         }
       }
       _addAllFromNamespace(definedNames, (library.context as InternalAnalysisContext).getPublicNamespace(library));
       return definedNames;
     } finally {
       visitedElements.remove(library);
     }
   }
 
   /**
    * Hide all of the given names by removing them from the given collection of defined names.
    *
    * @param definedNames the names that were defined before this operation
    * @param hiddenNames the names to be hidden
    */
-  void _hide(Map<String, Element> definedNames, List<String> hiddenNames) {
+  void _hide(HashMap<String, Element> definedNames, List<String> hiddenNames) {
     for (String name in hiddenNames) {
       definedNames.remove(name);
       definedNames.remove("${name}=");
     }
   }
 
   /**
    * Show only the given names by removing all other names from the given collection of defined
    * names.
    *
    * @param definedNames the names that were defined before this operation
    * @param shownNames the names to be shown
    */
-  Map<String, Element> _show(Map<String, Element> definedNames, List<String> shownNames) {
-    Map<String, Element> newNames = new Map<String, Element>();
+  HashMap<String, Element> _show(HashMap<String, Element> definedNames, List<String> shownNames) {
+    HashMap<String, Element> newNames = new HashMap<String, Element>();
     for (String name in shownNames) {
       Element element = definedNames[name];
       if (element != null) {
         newNames[name] = element;
       }
       String setterName = "${name}=";
       element = definedNames[setterName];
       if (element != null) {
         newNames[setterName] = element;
       }
@@ skipping 838 matching lines @@
    * Initialize a newly created error code to have the given type, message and correction.
    *
    * @param type the type of this error
    * @param message the template used to create the message to be displayed for the error
    * @param correction the template used to create the correction to be displayed for the error
    */
   const ResolverErrorCode.con2(String name, int ordinal, this.type, this.message, this.correction) : super(name, ordinal);
 
   @override
   ErrorSeverity get errorSeverity => type.severity;
+
+  @override
+  String get uniqueName => "${runtimeType.toString()}.${name}";
 }
 
 /**
  * Instances of the class `ResolverVisitor` are used to resolve the nodes within a single
  * compilation unit.
  */
 class ResolverVisitor extends ScopedVisitor {
   /**
    * The manager for the inheritance mappings.
    */
@@ skipping 419 matching lines @@
     }
     return null;
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
     _overrideManager.enterScope();
     try {
       super.visitFieldDeclaration(node);
     } finally {
-      Map<Element, DartType> overrides = _overrideManager.captureOverrides(node.fields);
+      HashMap<Element, DartType> overrides = _overrideManager.captureOverrides(node.fields);
       _overrideManager.exitScope();
       _overrideManager.applyOverrides(overrides);
     }
     return null;
   }
 
   @override
   Object visitForEachStatement(ForEachStatement node) {
     _overrideManager.enterScope();
     try {
@@ skipping 71 matching lines @@
     return null;
   }
 
   @override
   Object visitHideCombinator(HideCombinator node) => null;
 
   @override
   Object visitIfStatement(IfStatement node) {
     Expression condition = node.condition;
     safelyVisit(condition);
-    Map<Element, DartType> thenOverrides = null;
+    HashMap<Element, DartType> thenOverrides = null;
     Statement thenStatement = node.thenStatement;
     if (thenStatement != null) {
       _overrideManager.enterScope();
       try {
         _promoteManager.enterScope();
         try {
           _propagateTrueState(condition);
           // Type promotion.
           _promoteTypes(condition);
           _clearTypePromotionsIfPotentiallyMutatedIn(thenStatement);
           _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenStatement);
           // Visit "then".
           visitStatementInScope(thenStatement);
         } finally {
           _promoteManager.exitScope();
         }
       } finally {
         thenOverrides = _overrideManager.captureLocalOverrides();
         _overrideManager.exitScope();
       }
     }
-    Map<Element, DartType> elseOverrides = null;
+    HashMap<Element, DartType> elseOverrides = null;
     Statement elseStatement = node.elseStatement;
     if (elseStatement != null) {
       _overrideManager.enterScope();
       try {
         _propagateFalseState(condition);
         visitStatementInScope(elseStatement);
       } finally {
         elseOverrides = _overrideManager.captureLocalOverrides();
         _overrideManager.exitScope();
       }
@@ skipping 128 matching lines @@
     }
     return null;
   }
 
   @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _overrideManager.enterScope();
     try {
       super.visitTopLevelVariableDeclaration(node);
     } finally {
-      Map<Element, DartType> overrides = _overrideManager.captureOverrides(node.variables);
+      HashMap<Element, DartType> overrides = _overrideManager.captureOverrides(node.variables);
       _overrideManager.exitScope();
       _overrideManager.applyOverrides(overrides);
     }
     return null;
   }
 
   @override
   Object visitTypeName(TypeName node) => null;
 
   @override
@@ skipping 131 matching lines @@
    * 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 overrideVariable(VariableElement element, DartType potentialType) {
     if (potentialType == null || potentialType.isBottom) {
       return;
     }
-    if (element is PropertyInducingElement) {
-      PropertyInducingElement variable = element;
-      if (!variable.isConst && !variable.isFinal) {
-        return;
-      }
-    }
     DartType currentType = _getBestType(element);
     if (currentType == null || !currentType.isMoreSpecificThan(potentialType)) {
+      if (element is PropertyInducingElement) {
+        PropertyInducingElement variable = element;
+        if (!variable.isConst && !variable.isFinal) {
+          return;
+        }
+        (variable as PropertyInducingElementImpl).propagatedType = potentialType;
+      }
       _overrideManager.setType(element, potentialType);
     }
   }
 
   @override
   void visitForEachStatementInScope(ForEachStatement node) {
     //
     // We visit the iterator before the loop variable because the loop variable cannot be in scope
     // while visiting the iterator.
     //
@@ skipping 437 matching lines @@
    *
    * @param name the name being tested
    * @return `true` if the given name is a library-private name
    */
   static bool isPrivateName(String name) => name != null && StringUtilities.startsWithChar(name, PRIVATE_NAME_PREFIX);
 
   /**
    * A table mapping names that are defined in this scope to the element representing the thing
    * declared with that name.
    */
-  Map<String, Element> _definedNames = new Map<String, Element>();
+  HashMap<String, Element> _definedNames = new HashMap<String, Element>();
 
   /**
    * A flag indicating whether there are any names defined in this scope.
    */
   bool _hasName = false;
 
   /**
    * Add the given element to this scope. If there is already an element with the given name defined
    * in this scope, then an error will be generated and the original element will continue to be
    * mapped to the name. If there is an element with the given name in an enclosing scope, then a
@@ skipping 878 matching lines @@
  * * Every node representing an expression should be resolved to the Type of the expression.
  * </ol>
  */
 class StaticTypeAnalyzer extends SimpleAstVisitor<Object> {
   /**
    * Create a table mapping HTML tag names to the names of the classes (in 'dart:html') that
    * implement those tags.
    *
    * @return the table that was created
    */
-  static Map<String, String> _createHtmlTagToClassMap() {
-    Map<String, String> map = new Map<String, String>();
+  static HashMap<String, String> _createHtmlTagToClassMap() {
+    HashMap<String, String> map = new HashMap<String, String>();
     map["a"] = "AnchorElement";
     map["area"] = "AreaElement";
     map["br"] = "BRElement";
     map["base"] = "BaseElement";
     map["body"] = "BodyElement";
     map["button"] = "ButtonElement";
     map["canvas"] = "CanvasElement";
     map["content"] = "ContentElement";
     map["dl"] = "DListElement";
     map["datalist"] = "DataListElement";
@@ skipping 75 matching lines @@
   TypeOverrideManager _overrideManager;
 
   /**
    * The object keeping track of which elements have had their types promoted.
    */
   TypePromotionManager _promoteManager;
 
   /**
    * A table mapping [ExecutableElement]s to their propagated return types.
    */
-  Map<ExecutableElement, DartType> _propagatedReturnTypes = new Map<ExecutableElement, DartType>();
+  HashMap<ExecutableElement, DartType> _propagatedReturnTypes = new HashMap<ExecutableElement, DartType>();
 
   /**
    * A table mapping HTML tag names to the names of the classes (in 'dart:html') that implement
    * those tags.
    */
-  static Map<String, String> _HTML_ELEMENT_TO_CLASS_MAP = _createHtmlTagToClassMap();
+  static HashMap<String, String> _HTML_ELEMENT_TO_CLASS_MAP = _createHtmlTagToClassMap();
 
   /**
    * Initialize a newly created type analyzer.
    *
    * @param resolver the resolver driving this participant
    */
   StaticTypeAnalyzer(this._resolver) {
     _typeProvider = _resolver.typeProvider;
     _dynamicType = _typeProvider.dynamicType;
     _overrideManager = _resolver.overrideManager;
@@ skipping 742 matching lines @@
   }
 
   /**
    * See [visitSimpleIdentifier].
    */
   @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixedIdentifier = node.identifier;
     Element staticElement = prefixedIdentifier.staticElement;
     DartType staticType = _dynamicType;
+    DartType propagatedType = null;
     if (staticElement is ClassElement) {
       if (_isNotTypeLiteral(node)) {
         staticType = staticElement.type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (staticElement is FunctionTypeAliasElement) {
       if (_isNotTypeLiteral(node)) {
         staticType = staticElement.type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (staticElement is MethodElement) {
       staticType = staticElement.type;
     } else if (staticElement is PropertyAccessorElement) {
       staticType = _getTypeOfProperty(staticElement, node.prefix.staticType);
+      propagatedType = _getPropertyPropagatedType(staticElement, propagatedType);
     } else if (staticElement is ExecutableElement) {
       staticType = staticElement.type;
     } else if (staticElement is TypeParameterElement) {
       staticType = staticElement.type;
     } else if (staticElement is VariableElement) {
       staticType = staticElement.type;
     }
     _recordStaticType(prefixedIdentifier, staticType);
     _recordStaticType(node, staticType);
     Element propagatedElement = prefixedIdentifier.propagatedElement;
-    DartType propagatedType = null;
     if (propagatedElement is ClassElement) {
       if (_isNotTypeLiteral(node)) {
         propagatedType = propagatedElement.type;
       } else {
         propagatedType = _typeProvider.typeType;
       }
     } else if (propagatedElement is FunctionTypeAliasElement) {
       propagatedType = propagatedElement.type;
     } else if (propagatedElement is MethodElement) {
       propagatedType = propagatedElement.type;
     } else if (propagatedElement is PropertyAccessorElement) {
       propagatedType = _getTypeOfProperty(propagatedElement, node.prefix.staticType);
+      propagatedType = _getPropertyPropagatedType(propagatedElement, propagatedType);
     } else if (propagatedElement is ExecutableElement) {
       propagatedType = propagatedElement.type;
     } else if (propagatedElement is TypeParameterElement) {
       propagatedType = propagatedElement.type;
     } else if (propagatedElement is VariableElement) {
       propagatedType = propagatedElement.type;
     }
     DartType overriddenType = _overrideManager.getType(propagatedElement);
     if (propagatedType == null || (overriddenType != null && overriddenType.isMoreSpecificThan(propagatedType))) {
       propagatedType = overriddenType;
@@ skipping 185 matching lines @@
       VariableElement variable = element;
       staticType = _promoteManager.getStaticType(variable);
     } else if (element is PrefixElement) {
       return null;
     } else {
       staticType = _dynamicType;
     }
     _recordStaticType(node, staticType);
     // TODO(brianwilkerson) I think we want to repeat the logic above using the propagated element
     // to get another candidate for the propagated type.
-    DartType propagatedType = _overrideManager.getType(element);
+    DartType propagatedType = _getPropertyPropagatedType(element, null);
+    if (propagatedType == null) {
+      DartType overriddenType = _overrideManager.getType(element);
+      if (propagatedType == null || overriddenType != null && overriddenType.isMoreSpecificThan(propagatedType)) {
+        propagatedType = overriddenType;
+      }
+    }
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
       _recordPropagatedType(node, propagatedType);
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is
    * `String`.</blockquote>
    */
@@ skipping 202 matching lines @@
 
   /**
    * If the given element name can be mapped to the name of a class defined within the given
    * library, return the type specified by the argument.
    *
    * @param library the library in which the specified type would be defined
    * @param elementName the name of the element for which a type is being sought
    * @param nameMap an optional map used to map the element name to a type name
    * @return the type specified by the first argument in the argument list
    */
-  DartType _getElementNameAsType(LibraryElement library, String elementName, Map<String, String> nameMap) {
+  DartType _getElementNameAsType(LibraryElement library, String elementName, HashMap<String, String> nameMap) {
     if (elementName != null) {
       if (nameMap != null) {
         elementName = nameMap[elementName.toLowerCase()];
       }
       ClassElement returnType = library.getType(elementName);
       if (returnType != null) {
         return returnType.type;
       }
     }
     return null;
@@ skipping 67 matching lines @@
   /**
    * If the given argument list contains at least one argument, and if the argument is a simple
    * string literal, and if the value of the argument is the name of a class defined within the
    * given library, return the type specified by the argument.
    *
    * @param library the library in which the specified type would be defined
    * @param argumentList the list of arguments from which a type is to be extracted
    * @param nameMap an optional map used to map the element name to a type name
    * @return the type specified by the first argument in the argument list
    */
-  DartType _getFirstArgumentAsTypeWithMap(LibraryElement library, ArgumentList argumentList, Map<String, String> nameMap) => _getElementNameAsType(library, _getFirstArgumentAsString(argumentList), nameMap);
+  DartType _getFirstArgumentAsTypeWithMap(LibraryElement library, ArgumentList argumentList, HashMap<String, String> nameMap) => _getElementNameAsType(library, _getFirstArgumentAsString(argumentList), nameMap);
+
+  /**
+   * Return the propagated type of the given [Element], or `null`.
+   */
+  DartType _getPropertyPropagatedType(Element element, DartType currentType) {
+    if (element is PropertyAccessorElement) {
+      PropertyAccessorElement accessor = element;
+      if (accessor.isGetter) {
+        PropertyInducingElement variable = accessor.variable;
+        DartType propagatedType = variable.propagatedType;
+        if (currentType == null || propagatedType != null && propagatedType.isMoreSpecificThan(currentType)) {
+          return propagatedType;
+        }
+      }
+    }
+    return currentType;
+  }
 
   /**
    * Return the static type of the given expression.
    *
    * @param expression the expression whose type is to be returned
    * @return the static type of the given expression
    */
   DartType _getStaticType(Expression expression) {
     DartType type = expression.staticType;
     if (type == null) {
@@ skipping 194 matching lines @@
 }
 
 /**
  * Instances of this class manage the knowledge of what the set of subtypes are for a given type.
  */
 class SubtypeManager {
   /**
    * A map between [ClassElement]s and a set of [ClassElement]s that are subtypes of the
    * key.
    */
-  Map<ClassElement, Set<ClassElement>> _subtypeMap = new Map<ClassElement, Set<ClassElement>>();
+  HashMap<ClassElement, Set<ClassElement>> _subtypeMap = new HashMap<ClassElement, Set<ClassElement>>();
 
   /**
    * The set of all [LibraryElement]s that have been visited by the manager. This is used both
    * to prevent infinite loops in the recursive methods, and also as a marker for the scope of the
    * libraries visited by this manager.
    */
   Set<LibraryElement> _visitedLibraries = new Set<LibraryElement>();
 
   /**
    * Given some [ClassElement], return the set of all subtypes, and subtypes of subtypes.
@@ skipping 198 matching lines @@
   /**
    * The current override scope, or `null` if no scope has been entered.
    */
   TypeOverrideManager_TypeOverrideScope _currentScope;
 
   /**
    * Apply a set of overrides that were previously captured.
    *
    * @param overrides the overrides to be applied
    */
-  void applyOverrides(Map<Element, DartType> overrides) {
+  void applyOverrides(HashMap<Element, DartType> overrides) {
     if (_currentScope == null) {
       throw new IllegalStateException("Cannot apply overrides without a scope");
     }
     _currentScope.applyOverrides(overrides);
   }
 
   /**
    * Return a table mapping the elements whose type is overridden in the current scope to the
    * overriding type.
    *
    * @return the overrides in the current scope
    */
-  Map<Element, DartType> captureLocalOverrides() {
+  HashMap<Element, DartType> captureLocalOverrides() {
     if (_currentScope == null) {
       throw new IllegalStateException("Cannot capture local overrides without a scope");
     }
     return _currentScope.captureLocalOverrides();
   }
 
   /**
    * Return a map from the elements for the variables in the given list that have their types
    * overridden to the overriding type.
    *
    * @param variableList the list of variables whose overriding types are to be captured
    * @return a table mapping elements to their overriding types
    */
-  Map<Element, DartType> captureOverrides(VariableDeclarationList variableList) {
+  HashMap<Element, DartType> captureOverrides(VariableDeclarationList variableList) {
     if (_currentScope == null) {
       throw new IllegalStateException("Cannot capture overrides without a scope");
     }
     return _currentScope.captureOverrides(variableList);
   }
 
   /**
    * Enter a new override scope.
    */
   void enterScope() {
@@ skipping 44 matching lines @@
  */
 class TypeOverrideManager_TypeOverrideScope {
   /**
    * The outer scope in which types might be overridden.
    */
   final TypeOverrideManager_TypeOverrideScope _outerScope;
 
   /**
    * A table mapping elements to the overridden type of that element.
    */
-  Map<Element, DartType> _overridenTypes = new Map<Element, DartType>();
+  HashMap<Element, DartType> _overridenTypes = new HashMap<Element, DartType>();
 
   /**
    * Initialize a newly created scope to be an empty child of the given scope.
    *
    * @param outerScope the outer scope in which types might be overridden
    */
   TypeOverrideManager_TypeOverrideScope(this._outerScope);
 
   /**
    * Apply a set of overrides that were previously captured.
    *
    * @param overrides the overrides to be applied
    */
-  void applyOverrides(Map<Element, DartType> overrides) {
+  void applyOverrides(HashMap<Element, DartType> overrides) {
     for (MapEntry<Element, DartType> entry in getMapEntrySet(overrides)) {
       _overridenTypes[entry.getKey()] = entry.getValue();
     }
   }
 
   /**
    * Return a table mapping the elements whose type is overridden in the current scope to the
    * overriding type.
    *
    * @return the overrides in the current scope
    */
-  Map<Element, DartType> captureLocalOverrides() => _overridenTypes;
+  HashMap<Element, DartType> captureLocalOverrides() => _overridenTypes;
 
   /**
    * Return a map from the elements for the variables in the given list that have their types
    * overridden to the overriding type.
    *
    * @param variableList the list of variables whose overriding types are to be captured
    * @return a table mapping elements to their overriding types
    */
-  Map<Element, DartType> captureOverrides(VariableDeclarationList variableList) {
-    Map<Element, DartType> overrides = new Map<Element, DartType>();
+  HashMap<Element, DartType> captureOverrides(VariableDeclarationList variableList) {
+    HashMap<Element, DartType> overrides = new HashMap<Element, DartType>();
     if (variableList.isConst || variableList.isFinal) {
       for (VariableDeclaration variable in variableList.variables) {
         Element element = variable.element;
         if (element != null) {
           DartType type = _overridenTypes[element];
           if (type != null) {
             overrides[element] = type;
           }
         }
       }
@@ skipping 111 matching lines @@
  */
 class TypePromotionManager_TypePromoteScope {
   /**
    * The outer scope in which types might be promoter.
    */
   final TypePromotionManager_TypePromoteScope _outerScope;
 
   /**
    * A table mapping elements to the promoted type of that element.
    */
-  Map<Element, DartType> _promotedTypes = new Map<Element, DartType>();
+  HashMap<Element, DartType> _promotedTypes = new HashMap<Element, DartType>();
 
   /**
    * Initialize a newly created scope to be an empty child of the given scope.
    *
    * @param outerScope the outer scope in which types might be promoted
    */
   TypePromotionManager_TypePromoteScope(this._outerScope);
 
   /**
    * Returns the elements with promoted types.
@@ skipping 1592 matching lines @@
         parameterImpl.markPotentiallyMutatedInScope();
         // If we are in some closure, check if it is not the same as where variable is declared.
         if (_enclosingFunction != null && (element.enclosingElement != _enclosingFunction)) {
           parameterImpl.markPotentiallyMutatedInClosure();
         }
       }
     }
     return null;
   }
 }