New analyzer snapshot with MapIterator.

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';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
 import 'utilities_dart.dart';
 import 'utilities_general.dart';
+import 'utilities_collection.dart';
 import 'ast.dart';
 import 'parser.dart' show Parser, ParserErrorCode;
 import 'sdk.dart' show DartSdk, SdkLibrary;
 import 'element.dart';
 import 'html.dart' as ht;
 import 'engine.dart';
 import 'constant.dart';
 
 /**
  * Instances of the class `AngularCompilationUnitBuilder` build an Angular specific element
@@ skipping 206 matching lines @@
    * The [ClassDeclaration] that is currently being analyzed.
    */
   ClassDeclaration _classDeclaration;
 
   /**
    * The [ClassElementImpl] that is currently being analyzed.
    */
   ClassElementImpl _classElement;
 
   /**
-   * The [ToolkitObjectElement]s to set for [classElement].
-   */
-  List<ToolkitObjectElement> _classToolkitObjects = [];
-
-  /**
    * The [Annotation] that is currently being analyzed.
    */
   Annotation _annotation;
 
   /**
    * Initialize a newly created compilation unit element builder.
    *
    * @param errorListener the listener to which errors will be reported.
    * @param source the source containing the unit that will be analyzed
    * @param unit the compilation unit with built Dart element models
    */
   AngularCompilationUnitBuilder(this._errorListener, this._source, this._unit);
 
   /**
    * Builds Angular specific element models and adds them to the existing Dart elements.
    */
   void build() {
     _parseViews();
     // process classes
     for (CompilationUnitMember unitMember in _unit.declarations) {
       if (unitMember is ClassDeclaration) {
         this._classDeclaration = unitMember;
         this._classElement = _classDeclaration.element as ClassElementImpl;
-        this._classToolkitObjects.clear();
         // process annotations
         NodeList<Annotation> annotations = _classDeclaration.metadata;
         for (Annotation annotation in annotations) {
           // verify annotation
           if (annotation.arguments == null) {
             continue;
           }
           this._annotation = annotation;
           // @NgFilter
           if (_isAngularAnnotation(annotation, _NG_FILTER)) {
             _parseNgFilter();
             continue;
           }
           // @NgComponent
           if (_isAngularAnnotation(annotation, _NG_COMPONENT)) {
             _parseNgComponent();
             continue;
           }
           // @NgController
           if (_isAngularAnnotation(annotation, _NG_CONTROLLER)) {
             _parseNgController();
             continue;
           }
           // @NgDirective
           if (_isAngularAnnotation(annotation, _NG_DIRECTIVE)) {
             _parseNgDirective();
             continue;
           }
         }
-        // set toolkit objects
-        if (!_classToolkitObjects.isEmpty) {
-          List<ToolkitObjectElement> objects = _classToolkitObjects;
-          _classElement.toolkitObjects = new List.from(objects);
-        }
       }
     }
   }
 
   /**
    * @return the argument [Expression] with given name form [annotation], may be
    *         `null` if not found.
    */
   Expression _getArgument(String name) {
     List<Expression> arguments = _annotation.arguments.arguments;
@@ skipping 89 matching lines @@
     // create
     if (isValid) {
       AngularComponentElementImpl element = new AngularComponentElementImpl(name, nameOffset, _annotation.offset);
       element.selector = selector;
       element.templateUri = templateUri;
       element.templateUriOffset = templateUriOffset;
       element.styleUri = styleUri;
       element.styleUriOffset = styleUriOffset;
       element.properties = _parseNgComponentProperties();
       element.scopeProperties = _parseScopeProperties();
-      _classToolkitObjects.add(element);
+      _classElement.addToolkitObjects(element);
     }
   }
 
   /**
    * Parses [AngularPropertyElement]s from [annotation] and [classDeclaration].
    */
   List<AngularPropertyElement> _parseNgComponentProperties() {
     List<AngularPropertyElement> properties = [];
     _parseNgComponentProperties_fromMap(properties);
     _parseNgComponentProperties_fromFields(properties);
@@ skipping 131 matching lines @@
         _reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
         isValid = false;
       }
     }
     // create
     if (isValid) {
       String name = _getStringArgument(_PUBLISH_AS);
       int nameOffset = _getStringArgumentOffset(_PUBLISH_AS);
       AngularControllerElementImpl element = new AngularControllerElementImpl(name, nameOffset);
       element.selector = selector;
-      _classToolkitObjects.add(element);
+      _classElement.addToolkitObjects(element);
     }
   }
 
   void _parseNgDirective() {
     bool isValid = true;
     // selector
     AngularSelectorElement selector = null;
     if (!_hasStringArgument(_SELECTOR)) {
       _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
       isValid = false;
     } else {
       SimpleStringLiteral selectorLiteral = _getStringLiteral(_SELECTOR);
       selector = _parseSelectorFromString(selectorLiteral);
       if (selector == null) {
         _reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
         isValid = false;
       }
     }
     // create
     if (isValid) {
       int offset = _annotation.offset;
       AngularDirectiveElementImpl element = new AngularDirectiveElementImpl(offset);
       element.selector = selector;
       element.properties = _parseNgComponentProperties();
-      _classToolkitObjects.add(element);
+      _classElement.addToolkitObjects(element);
     }
   }
 
   void _parseNgFilter() {
     bool isValid = true;
     // name
     if (!_hasStringArgument(_NAME)) {
       _reportErrorForAnnotation(AngularCode.MISSING_NAME, []);
       isValid = false;
     }
     // create
     if (isValid) {
       String name = _getStringArgument(_NAME);
       int nameOffset = _getStringArgumentOffset(_NAME);
-      _classToolkitObjects.add(new AngularFilterElementImpl(name, nameOffset));
+      _classElement.addToolkitObjects(new AngularFilterElementImpl(name, nameOffset));
     }
   }
 
   List<AngularScopePropertyElement> _parseScopeProperties() {
     List<AngularScopePropertyElement> properties = [];
     _classDeclaration.accept(new RecursiveAstVisitor_AngularCompilationUnitBuilder_parseScopeProperties(properties));
     return new List.from(properties);
   }
 
   /**
@@ skipping 1579 matching lines @@
    * @param arguments the arguments used to compose the error message
    */
   void _reportValueError(ErrorCode errorCode, ht.XmlAttributeNode attribute, List<Object> arguments) {
     int offset = attribute.valueToken.offset + 1;
     int length = attribute.valueToken.length - 2;
     _reportErrorForOffset(errorCode, offset, length, arguments);
   }
 }
 
 /**
+ * Instances of the class `PolymerCompilationUnitBuilder` build a Polymer specific element
+ * model for a single compilation unit.
+ */
+class PolymerCompilationUnitBuilder {
+  static String _CUSTOM_TAG = "CustomTag";
+
+  static Element getElement(AstNode node, int offset) {
+    // maybe node is not SimpleStringLiteral
+    if (node is! SimpleStringLiteral) {
+      return null;
+    }
+    SimpleStringLiteral literal = node as SimpleStringLiteral;
+    // maybe has PolymerElement
+    {
+      Element element = literal.toolkitElement;
+      if (element is PolymerElement) {
+        return element;
+      }
+    }
+    // no Element
+    return null;
+  }
+
+  /**
+   * The compilation unit with built Dart element models.
+   */
+  final CompilationUnit _unit;
+
+  /**
+   * The [ClassDeclaration] that is currently being analyzed.
+   */
+  ClassDeclaration _classDeclaration;
+
+  /**
+   * The [ClassElementImpl] that is currently being analyzed.
+   */
+  ClassElementImpl _classElement;
+
+  /**
+   * The [Annotation] that is currently being analyzed.
+   */
+  Annotation _annotation;
+
+  /**
+   * Initialize a newly created compilation unit element builder.
+   *
+   * @param unit the compilation unit with built Dart element models
+   */
+  PolymerCompilationUnitBuilder(this._unit);
+
+  /**
+   * Builds Polymer specific element models and adds them to the existing Dart elements.
+   */
+  void build() {
+    // process classes
+    for (CompilationUnitMember unitMember in _unit.declarations) {
+      if (unitMember is ClassDeclaration) {
+        this._classDeclaration = unitMember;
+        this._classElement = _classDeclaration.element as ClassElementImpl;
+        // process annotations
+        NodeList<Annotation> annotations = _classDeclaration.metadata;
+        for (Annotation annotation in annotations) {
+          // verify annotation
+          if (annotation.arguments == null) {
+            continue;
+          }
+          this._annotation = annotation;
+          // @CustomTag
+          if (_isAnnotation(annotation, _CUSTOM_TAG)) {
+            _parseCustomTag();
+            continue;
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Checks if given [Annotation] is an annotation with required name.
+   */
+  bool _isAnnotation(Annotation annotation, String name) {
+    Element element = annotation.element;
+    if (element is ConstructorElement) {
+      ConstructorElement constructorElement = element;
+      return constructorElement.returnType.displayName == name;
+    }
+    return false;
+  }
+
+  void _parseCustomTag() {
+    List<Expression> arguments = _annotation.arguments.arguments;
+    if (arguments.length == 1) {
+      Expression nameExpression = arguments[0];
+      if (nameExpression is SimpleStringLiteral) {
+        SimpleStringLiteral nameLiteral = nameExpression;
+        String name = nameLiteral.value;
+        int nameOffset = nameLiteral.valueOffset;
+        PolymerTagDartElementImpl element = new PolymerTagDartElementImpl(name, nameOffset, _classElement);
+        _classElement.addToolkitObjects(element);
+        nameLiteral.toolkitElement = element;
+      }
+    }
+  }
+}
+
+/**
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
  */
 class BestPracticesVerifier extends RecursiveAstVisitor<Object> {
-  static String _GETTER = "getter";
-
   static String _HASHCODE_GETTER_NAME = "hashCode";
 
-  static String _METHOD = "method";
-
   static String _NULL_TYPE_NAME = "Null";
 
-  static String _SETTER = "setter";
-
   static String _TO_INT_METHOD_NAME = "toInt";
 
   /**
    * Given a parenthesized expression, this returns the parent (or recursively grand-parent) of the
    * expression that is a parenthesized expression, but whose parent is not a parenthesized
    * expression.
    *
    * For example given the code `(((e)))`: `(e) -> (((e)))`.
    *
    * @param parenthesizedExpression some expression whose parent is a parenthesized expression
@@ skipping 33 matching lines @@
 
   @override
   Object visitAsExpression(AsExpression node) {
     _checkForUnnecessaryCast(node);
     return super.visitAsExpression(node);
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.TokenType operatorType = node.operator.type;
-    if (operatorType != sc.TokenType.EQ) {
+    if (operatorType == sc.TokenType.EQ) {
+      _checkForUseOfVoidResult(node.rightHandSide);
+      _checkForInvalidAssignment(node.leftHandSide, node.rightHandSide);
+    } else {
       _checkForDeprecatedMemberUse(node.bestElement, node);
-    } else {
-      _checkForUseOfVoidResult(node.rightHandSide);
     }
     return super.visitAssignmentExpression(node);
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     _checkForDivisionOptimizationHint(node);
     _checkForDeprecatedMemberUse(node.bestElement, node);
     return super.visitBinaryExpression(node);
   }
@@ skipping 81 matching lines @@
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     _checkForDeprecatedMemberUse(node.staticElement, node);
     return super.visitSuperConstructorInvocation(node);
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     _checkForUseOfVoidResult(node.initializer);
+    _checkForInvalidAssignment(node.name, node.initializer);
     return super.visitVariableDeclaration(node);
   }
 
   /**
    * Check for the passed is expression for the unnecessary type check hint codes as well as null
    * checks expressed using an is expression.
    *
    * @param node the is expression to check
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#TYPE_CHECK_IS_NOT_NULL
@@ skipping 225 matching lines @@
         if (_TO_INT_METHOD_NAME == methodInvocation.methodName.name && methodInvocation.argumentList.arguments.isEmpty) {
           _errorReporter.reportErrorForNode(HintCode.DIVISION_OPTIMIZATION, methodInvocation, []);
           return true;
         }
       }
     }
     return false;
   }
 
   /**
+   * This verifies that the passed left hand side and right hand side represent a valid assignment.
+   *
+   * This method corresponds to ErrorVerifier.checkForInvalidAssignment.
+   *
+   * @param lhs the left hand side expression
+   * @param rhs the right hand side expression
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see HintCode#INVALID_ASSIGNMENT
+   */
+  bool _checkForInvalidAssignment(Expression lhs, Expression rhs) {
+    if (lhs == null || rhs == null) {
+      return false;
+    }
+    VariableElement leftElement = ErrorVerifier.getVariableElement(lhs);
+    DartType leftType = (leftElement == null) ? ErrorVerifier.getStaticType(lhs) : leftElement.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) {
+          leftName = ErrorVerifier.getExtendedDisplayName(leftType);
+          rightName = ErrorVerifier.getExtendedDisplayName(bestRightType);
+        }
+        _errorReporter.reportErrorForNode(HintCode.INVALID_ASSIGNMENT, rhs, [rightName, leftName]);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
    * Generate a hint for functions or methods that have a return type, but do not have a return
    * statement on all branches. At the end of blocks with no return, Dart implicitly returns
    * `null`, avoiding these implicit returns is considered a best practice.
    *
    * @param node the binary expression to check
    * @param body the function body
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#MISSING_RETURN
    */
   bool _checkForMissingReturn(TypeName returnType, FunctionBody body) {
@@ skipping 37 matching lines @@
       PropertyAccessorElement hashCodeElement = classElement.getGetter(_HASHCODE_GETTER_NAME);
       if (hashCodeElement == null) {
         _errorReporter.reportErrorForNode(HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE, node.name, [classElement.displayName]);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * Checks that if the passed method declaration is private, it does not override a private member
-   * in a superclass.
-   *
-   * @param node the method declaration to check
-   * @return `true` if and only if a hint code is generated on the passed node
-   * @see HintCode#OVERRIDDING_PRIVATE_MEMBER
-   */
-  bool _checkForOverridingPrivateMember(MethodDeclaration node) {
-    // If not in an enclosing class, return false
-    if (_enclosingClass == null) {
-      return false;
-    }
-    // If the member is not private, return false
-    if (!Identifier.isPrivateName(node.name.name)) {
-      return false;
-    }
-    // Get the element of the member, if null, return false
-    ExecutableElement executableElement = node.element;
-    if (executableElement == null) {
-      return false;
-    }
-    // Loop through all of the superclasses looking for a matching method or accessor
-    // TODO(jwren) If the HintGenerator needs or has easy access to the InheritanceManager in the
-    // future then this could be refactored down to be more readable, however, since we are only
-    // looking through super classes (and not the entire interface graph) there is no pressing need
-    String elementName = executableElement.name;
-    bool isGetterOrSetter = executableElement is PropertyAccessorElement;
-    InterfaceType superType = _enclosingClass.supertype;
-    if (superType == null) {
-      return false;
-    }
-    ClassElement classElement = superType.element;
-    while (classElement != null) {
-      if (_enclosingClass.library != classElement.library) {
-        if (isGetterOrSetter) {
-          PropertyAccessorElement overriddenAccessor = null;
-          List<PropertyAccessorElement> accessors = classElement.accessors;
-          for (PropertyAccessorElement propertyAccessorElement in accessors) {
-            if (elementName == propertyAccessorElement.name) {
-              overriddenAccessor = propertyAccessorElement;
-              break;
-            }
-          }
-          if (overriddenAccessor != null) {
-            String memberType = (executableElement as PropertyAccessorElement).isGetter ? _GETTER : _SETTER;
-            _errorReporter.reportErrorForNode(HintCode.OVERRIDDING_PRIVATE_MEMBER, node.name, [
-                memberType,
-                executableElement.displayName,
-                classElement.displayName]);
-            return true;
-          }
-        } else {
-          MethodElement overriddenMethod = classElement.getMethod(elementName);
-          if (overriddenMethod != null) {
-            _errorReporter.reportErrorForNode(HintCode.OVERRIDDING_PRIVATE_MEMBER, node.name, [
-                _METHOD,
-                executableElement.displayName,
-                classElement.displayName]);
-            return true;
-          }
-        }
-      }
-      superType = classElement.supertype;
-      classElement = superType != null ? superType.element : null;
-    }
-    return false;
-  }
-
-  /**
    * Check for the passed as expression for the [HintCode#UNNECESSARY_CAST] hint code.
    *
    * @param node the as expression to check
    * @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;
@@ skipping 231 matching lines @@
       CatchClause catchClause = catchClauses[i];
       if (catchClause.onKeyword != null) {
         // on-catch clause found, verify that the exception type is not a subtype of a previous
         // on-catch exception type
         TypeName typeName = catchClause.exceptionType;
         if (typeName != null && typeName.type != null) {
           DartType currentType = typeName.type;
           if (currentType.isObject) {
             // Found catch clause clause that has Object as an exception type, this is equivalent to
             // having a catch clause that doesn't have an exception type, visit the block, but
-             // generate an error on any following catch clauses (and don't visit them).
+            // generate an error on any following catch clauses (and don't visit them).
             _safelyVisit(catchClause);
             if (i + 1 != numOfCatchClauses) {
-               // this catch clause is not the last in the try statement
+              // this catch clause is not the last in the try statement
               CatchClause nextCatchClause = catchClauses[i + 1];
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = nextCatchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
               return null;
             }
           }
           for (DartType type in visitedTypes) {
             if (currentType.isSubtypeOf(type)) {
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = catchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_ON_CATCH_SUBTYPE, offset, length, [currentType.displayName, type.displayName]);
               return null;
             }
           }
           visitedTypes.add(currentType);
         }
         _safelyVisit(catchClause);
       } else {
-         // Found catch clause clause that doesn't have an exception type, visit the block, but
+        // Found catch clause clause that doesn't have an exception type, visit the block, but
         // generate an error on any following catch clauses (and don't visit them).
         _safelyVisit(catchClause);
         if (i + 1 != numOfCatchClauses) {
           // this catch clause is not the last in the try statement
           CatchClause nextCatchClause = catchClauses[i + 1];
           CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
           int offset = nextCatchClause.offset;
           int length = lastCatchClause.end - offset;
           _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
           return null;
@@ skipping 34 matching lines @@
   ValidResult _getConstantBooleanValue(Expression expression) {
     if (expression is BooleanLiteral) {
       if (expression.value) {
         return new ValidResult(new DartObjectImpl(null, BoolState.from(true)));
       } else {
         return new ValidResult(new DartObjectImpl(null, BoolState.from(false)));
       }
     }
     // Don't consider situations where we could evaluate to a constant boolean expression with the
     // ConstantVisitor
-//
-       // else {
-//
-         // EvaluationResultImpl result = expression.accept(new ConstantVisitor());
-//
-         // if (result == ValidResult.RESULT_TRUE) {
-//
-           // return ValidResult.RESULT_TRUE;
-//
-         // } else if (result == ValidResult.RESULT_FALSE) {
-//
-           // return ValidResult.RESULT_FALSE;
-//
-         // }
-//
-         // return null;
-//
-       // }
+    //    else {
+    //      EvaluationResultImpl result = expression.accept(new ConstantVisitor());
+    //      if (result == ValidResult.RESULT_TRUE) {
+    //        return ValidResult.RESULT_TRUE;
+    //      } else if (result == ValidResult.RESULT_FALSE) {
+    //        return ValidResult.RESULT_FALSE;
+    //      }
+    //      return null;
+    //    }
     return null;
   }
 
   /**
    * Return `true` if and only if the passed expression is resolved to a constant variable.
    *
    * @param expression some conditional expression
    * @return `true` if and only if the passed expression is resolved to a constant variable
    */
   bool _isDebugConstant(Expression expression) {
@@ skipping 5463 matching lines @@
           }
           if (!alreadyInList) {
             list.add(newExecutableElementEntry);
           }
         }
       }
     }
     //
     // Loop through the entries in the unionMap, adding them to the resultMap appropriately.
     //
-    for (MapEntry<String, List<ExecutableElement>> entry in getMapEntrySet(unionMap)) {
-      String key = entry.getKey();
-      List<ExecutableElement> list = entry.getValue();
+    for (MapIterator<String, List<ExecutableElement>> iter = SingleMapIterator.forMap(unionMap); iter.moveNext();) {
+      String key = iter.key;
+      List<ExecutableElement> list = iter.value;
       int numOfEltsWithMatchingNames = list.length;
       if (numOfEltsWithMatchingNames == 1) {
         //
         // Example: class A inherits only 1 method named 'm'.  Since it is the only such method, it
         // is inherited.
         // Another example: class A inherits 2 methods named 'm' from 2 different interfaces, but
         // they both have the same signature, so it is the method inherited.
         //
         resultMap.put(key, list[0]);
       } else {
@@ skipping 55 matching lines @@
             //
             // Example: class A inherited only 2 method named 'm'. One has the function type
             // '() -> dynamic' and one has the function type '([int]) -> dynamic'. Since the second
             // method is a subtype of all the others, it is the inherited method.
             // Tests: InheritanceManagerTest.test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_*
             //
             resultMap.put(key, elements[subtypesOfAllOtherTypesIndexes[0]]);
           } else {
             if (subtypesOfAllOtherTypesIndexes.isEmpty) {
               //
+              // Determine if the current class has a method or accessor with the member name, if it
+              // does then then this class does not "inherit" from any of the supertypes.
+              // See issue 16134.
+              //
+              bool classHasMember = false;
+              if (allMethods) {
+                classHasMember = classElt.getMethod(key) != null;
+              } else {
+                List<PropertyAccessorElement> accessors = classElt.accessors;
+                for (int i = 0; i < accessors.length; i++) {
+                  if (accessors[i].name == key) {
+                    classHasMember = true;
+                  }
+                }
+              }
+              //
               // Example: class A inherited only 2 method named 'm'. One has the function type
               // '() -> int' and one has the function type '() -> String'. Since neither is a subtype
               // of the other, we create a warning, and have this class inherit nothing.
               //
-              String firstTwoFuntionTypesStr = "${executableElementTypes[0].toString()}, ${executableElementTypes[1].toString()}";
-              _reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE, [key, firstTwoFuntionTypesStr]);
+              if (!classHasMember) {
+                String firstTwoFuntionTypesStr = "${executableElementTypes[0].toString()}, ${executableElementTypes[1].toString()}";
+                _reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE, [key, firstTwoFuntionTypesStr]);
+              }
             } else {
               //
               // Example: class A inherits 2 methods named 'm'. One has the function type
               // '(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++) {
@@ skipping 1040 matching lines @@
           Source importedSource = importDirective.source;
           if (importedSource != null) {
             // The imported source will be null if the URI in the import directive was invalid.
             Library importedLibrary = _libraryMap[importedSource];
             if (importedLibrary != null) {
               ImportElementImpl importElement = new ImportElementImpl(directive.offset);
               StringLiteral uriLiteral = importDirective.uri;
               importElement.uriOffset = uriLiteral.offset;
               importElement.uriEnd = uriLiteral.end;
               importElement.uri = uriContent;
+              importElement.deferred = importDirective.deferredToken != null;
               importElement.combinators = _buildCombinators(importDirective);
               LibraryElement importedLibraryElement = importedLibrary.libraryElement;
               if (importedLibraryElement != null) {
                 importElement.importedLibrary = importedLibraryElement;
               }
               SimpleIdentifier prefixNode = directive.prefix;
               if (prefixNode != null) {
                 importElement.prefixOffset = prefixNode.offset;
                 String prefixName = prefixNode.name;
                 PrefixElementImpl prefix = nameToPrefixMap[prefixName];
@@ skipping 329 matching lines @@
     // Angular
     timeCounter = PerformanceStatistics.angular.start();
     try {
       for (Source source in library.compilationUnitSources) {
         CompilationUnit ast = library.getAST(source);
         new AngularCompilationUnitBuilder(_errorListener, source, ast).build();
       }
     } finally {
       timeCounter.stop();
     }
+    // Polymer
+    timeCounter = PerformanceStatistics.polymer.start();
+    try {
+      for (Source source in library.compilationUnitSources) {
+        CompilationUnit ast = library.getAST(source);
+        new PolymerCompilationUnitBuilder(ast).build();
+      }
+    } finally {
+      timeCounter.stop();
+    }
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
    *
    * @param librarySource the source representing the library containing the directive
    * @param directive the directive which URI should be resolved
    * @return the result of resolving the URI against the URI of the library
    */
@@ skipping 202 matching lines @@
             // The imported source will be null if the URI in the import directive was invalid.
             ResolvableLibrary importedLibrary = _libraryMap[importedSource];
             if (importedLibrary != null) {
               ImportElementImpl importElement = new ImportElementImpl(directive.offset);
               StringLiteral uriLiteral = importDirective.uri;
               if (uriLiteral != null) {
                 importElement.uriOffset = uriLiteral.offset;
                 importElement.uriEnd = uriLiteral.end;
               }
               importElement.uri = uriContent;
+              importElement.deferred = importDirective.deferredToken != null;
               importElement.combinators = _buildCombinators(importDirective);
               LibraryElement importedLibraryElement = importedLibrary.libraryElement;
               if (importedLibraryElement != null) {
                 importElement.importedLibrary = importedLibraryElement;
               }
               SimpleIdentifier prefixNode = directive.prefix;
               if (prefixNode != null) {
                 importElement.prefixOffset = prefixNode.offset;
                 String prefixName = prefixNode.name;
                 PrefixElementImpl prefix = nameToPrefixMap[prefixName];
@@ skipping 189 matching lines @@
     timeCounter = PerformanceStatistics.angular.start();
     try {
       for (ResolvableCompilationUnit unit in library.resolvableCompilationUnits) {
         Source source = unit.source;
         CompilationUnit ast = unit.compilationUnit;
         new AngularCompilationUnitBuilder(_errorListener, source, ast).build();
       }
     } finally {
       timeCounter.stop();
     }
+    // Polymer
+    timeCounter = PerformanceStatistics.polymer.start();
+    try {
+      for (Source source in library.compilationUnitSources) {
+        CompilationUnit ast = library.getAST(source);
+        new PolymerCompilationUnitBuilder(ast).build();
+      }
+    } finally {
+      timeCounter.stop();
+    }
   }
 }
 
 /**
  * This class is used to replace uses of `HashMap<String, ExecutableElement>` which are not as
  * performant as this class.
  */
 class MemberMap {
   /**
    * The current size of this map.
@@ skipping 4377 matching lines @@
    * @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) {
-    for (MapEntry<Element, DartType> entry in getMapEntrySet(overrides)) {
-      _overridenTypes[entry.getKey()] = entry.getValue();
+    for (MapIterator<Element, DartType> iter = SingleMapIterator.forMap(overrides); iter.moveNext();) {
+      _overridenTypes[iter.key] = iter.value;
     }
   }
 
   /**
    * 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;
@@ skipping 2329 matching lines @@
     return new Namespace(definedNames);
   }
 
   /**
    * Add all of the names in the given namespace to the given mapping table.
    *
    * @param definedNames the mapping table to which the names in the given namespace are to be added
    * @param namespace the namespace containing the names to be added to this namespace
    */
   void _addAllFromMap(Map<String, Element> definedNames, Map<String, Element> newNames) {
-    for (MapEntry<String, Element> entry in getMapEntrySet(newNames)) {
-      definedNames[entry.getKey()] = entry.getValue();
+    for (MapIterator<String, Element> iter = SingleMapIterator.forMap(newNames); iter.moveNext();) {
+      definedNames[iter.key] = iter.value;
     }
   }
 
   /**
    * Add all of the names in the given namespace to the given mapping table.
    *
    * @param definedNames the mapping table to which the names in the given namespace are to be added
    * @param namespace the namespace containing the names to be added to this namespace
    */
   void _addAllFromNamespace(Map<String, Element> definedNames, Namespace namespace) {
@@ skipping 61 matching lines @@
   /**
    * 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) {
     if (prefixElement != null) {
       String prefix = prefixElement.name;
       Map<String, Element> newNames = new Map<String, Element>();
-      for (MapEntry<String, Element> entry in getMapEntrySet(definedNames)) {
-        newNames["${prefix}.${entry.getKey()}"] = entry.getValue();
+      for (MapIterator<String, Element> iter = SingleMapIterator.forMap(definedNames); iter.moveNext();) {
+        newNames["${prefix}.${iter.key}"] = iter.value;
       }
       return newNames;
     } else {
       return definedNames;
     }
   }
 
   /**
    * Create a mapping table representing the export namespace of the given library.
    *
@@ skipping 728 matching lines @@
     return super.visitSimpleIdentifier(node);
   }
 }
 
 /**
  * Instances of the class `ErrorVerifier` traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver.
  */
 class ErrorVerifier extends RecursiveAstVisitor<Object> {
   /**
+   * Return a display name for the given type that includes the path to the compilation unit in
+   * which the type is defined.
+   *
+   * @param type the type for which an extended display name is to be returned
+   * @return a display name that can help distiguish between two types with the same name
+   */
+  static String getExtendedDisplayName(DartType type) {
+    Element element = type.element;
+    if (element != null) {
+      Source source = element.source;
+      if (source != null) {
+        return "${type.displayName} (${source.fullName})";
+      }
+    }
+    return type.displayName;
+  }
+
+  /**
+   * Return the static type of the given expression that is to be used for type analysis.
+   *
+   * @param expression the expression whose type is to be returned
+   * @return the static type of the given expression
+   */
+  static DartType getStaticType(Expression expression) {
+    DartType type = expression.staticType;
+    if (type == null) {
+      // TODO(brianwilkerson) This should never happen.
+      return DynamicTypeImpl.instance;
+    }
+    return type;
+  }
+
+  /**
+   * Return the variable element represented by the given expression, or `null` if there is no
+   * such element.
+   *
+   * @param expression the expression whose element is to be returned
+   * @return the variable element represented by the expression
+   */
+  static VariableElement getVariableElement(Expression expression) {
+    if (expression is Identifier) {
+      Element element = expression.staticElement;
+      if (element is VariableElement) {
+        return element;
+      }
+    }
+    return null;
+  }
+
+  /**
    * The error reporter by which errors will be reported.
    */
   final ErrorReporter _errorReporter;
 
   /**
    * The current library that is being analyzed.
    */
   final LibraryElement _currentLibrary;
 
   /**
-   * The type representing the type 'dynamic'.
-   */
-  DartType _dynamicType;
-
-  /**
    * The type representing the type 'bool'.
    */
   InterfaceType _boolType;
 
   /**
    * The type representing the type 'int'.
    */
   InterfaceType _intType;
 
   /**
@@ skipping 187 matching lines @@
   ErrorVerifier(this._errorReporter, this._currentLibrary, this._typeProvider, this._inheritanceManager) {
     this._isInSystemLibrary = _currentLibrary.source.isInSystemLibrary;
     this._hasExtUri = _currentLibrary.hasExtUri;
     _isEnclosingConstructorConst = false;
     _isInCatchClause = false;
     _isInStaticVariableDeclaration = false;
     _isInInstanceVariableDeclaration = false;
     _isInInstanceVariableInitializer = false;
     _isInConstructorInitializer = false;
     _isInStaticMethod = false;
-    _dynamicType = _typeProvider.dynamicType;
     _boolType = _typeProvider.boolType;
     _intType = _typeProvider.intType;
     _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = <InterfaceType> [
         _typeProvider.nullType,
         _typeProvider.numType,
         _intType,
         _typeProvider.doubleType,
         _boolType,
         _typeProvider.stringType];
   }
 
   @override
   Object visitArgumentList(ArgumentList node) {
     _checkForArgumentTypesNotAssignableInList(node);
     return super.visitArgumentList(node);
   }
 
   @override
   Object visitAssertStatement(AssertStatement node) {
     _checkForNonBoolExpression(node);
     return super.visitAssertStatement(node);
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
-    sc.Token operator = node.operator;
-    sc.TokenType operatorType = operator.type;
+    sc.TokenType operatorType = node.operator.type;
     if (operatorType == sc.TokenType.EQ) {
       _checkForInvalidAssignment(node.leftHandSide, node.rightHandSide);
     } else {
       _checkForInvalidCompoundAssignment(node);
     }
     _checkForAssignmentToFinal(node.leftHandSide);
     _checkForArgumentTypeNotAssignableForArgument(node.rightHandSide);
     return super.visitAssignmentExpression(node);
   }
 
@@ skipping 44 matching lines @@
       _isInCatchClause = previousIsInCatchClause;
     }
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       _isInNativeClass = node.nativeClause != null;
       _enclosingClass = node.element;
+      ExtendsClause extendsClause = node.extendsClause;
+      ImplementsClause implementsClause = node.implementsClause;
       WithClause withClause = node.withClause;
-      ImplementsClause implementsClause = node.implementsClause;
-      ExtendsClause extendsClause = node.extendsClause;
       _checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
       _checkForMemberWithClassName();
       _checkForNoDefaultSuperConstructorImplicit(node);
       _checkForConflictingTypeVariableErrorCodes(node);
       // Only do error checks on the clause nodes if there is a non-null clause
       if (implementsClause != null || extendsClause != null || withClause != null) {
         // Only check for all of the inheritance logic around clauses if there isn't an error code
         // such as "Cannot extend double" already on the class.
         if (!_checkForImplementsDisallowedClass(implementsClause) && !_checkForExtendsDisallowedClass(extendsClause) && !_checkForAllMixinErrorCodes(withClause)) {
-          _checkForNonAbstractClassInheritsAbstractMember(node);
+          _checkForNonAbstractClassInheritsAbstractMember(node.name);
           _checkForInconsistentMethodInheritance();
           _checkForRecursiveInterfaceInheritance(_enclosingClass);
           _checkForConflictingGetterAndMethod();
           _checkForConflictingInstanceGetterAndSuperclassMember();
           _checkImplementsSuperClass(node);
           _checkImplementsFunctionWithoutCall(node);
         }
       }
       // initialize initialFieldElementsMap
       ClassElement classElement = node.element;
@@ skipping 13 matching lines @@
     } finally {
       _isInNativeClass = false;
       _initialFieldElementsMap = null;
       _enclosingClass = outerClass;
     }
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     _checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
-    _checkForExtendsDisallowedClassInTypeAlias(node);
-    _checkForImplementsDisallowedClass(node.implementsClause);
-    _checkForAllMixinErrorCodes(node.withClause);
     ClassElement outerClassElement = _enclosingClass;
     try {
       _enclosingClass = node.element;
-      _checkForRecursiveInterfaceInheritance(node.element);
-      _checkForTypeAliasCannotReferenceItself_mixin(node);
+      // Only check for all of the inheritance logic around clauses if there isn't an error code
+      // such as "Cannot extend double" already on the class.
+      if (!_checkForExtendsDisallowedClassInTypeAlias(node) && !_checkForImplementsDisallowedClass(node.implementsClause) && !_checkForAllMixinErrorCodes(node.withClause)) {
+        _checkForRecursiveInterfaceInheritance(node.element);
+        _checkForTypeAliasCannotReferenceItself_mixin(node);
+        _checkForNonAbstractClassInheritsAbstractMember(node.name);
+      }
     } finally {
       _enclosingClass = outerClassElement;
     }
     return super.visitClassTypeAlias(node);
   }
 
   @override
   Object visitComment(Comment node) {
     _isInComment = true;
     try {
       return super.visitComment(node);
     } finally {
       _isInComment = false;
     }
   }
 
   @override
+  Object visitCompilationUnit(CompilationUnit node) {
+    _checkForDeferredPrefixCollisions(node);
+    return super.visitCompilationUnit(node);
+  }
+
+  @override
   Object visitConditionalExpression(ConditionalExpression node) {
     _checkForNonBoolCondition(node.condition);
     return super.visitConditionalExpression(node);
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
@@ skipping 180 matching lines @@
     _checkForNonBoolCondition(node.condition);
     return super.visitIfStatement(node);
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     ImportElement importElement = node.element;
     if (importElement != null) {
       _checkForImportDuplicateLibraryName(node, importElement);
       _checkForImportInternalLibrary(node, importElement);
+      if (importElement.isDeferred) {
+        _checkForLoadLibraryFunction(node, importElement);
+      }
     }
     return super.visitImportDirective(node);
   }
 
   @override
   Object visitIndexExpression(IndexExpression node) {
     _checkForArgumentTypeNotAssignableForArgument(node.index);
     return super.visitIndexExpression(node);
   }
 
@@ skipping 382 matching lines @@
             _errorReporter.reportErrorForNode(CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER, fieldName, []);
             foundError = true;
           } else if (state == INIT_STATE.INIT_IN_INITIALIZERS) {
             _errorReporter.reportErrorForNode(CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS, fieldName, [fieldElement.displayName]);
             foundError = true;
           }
         }
       }
     }
     // Visit all of the states in the map to ensure that none were never initialized.
-    for (MapEntry<FieldElement, INIT_STATE> entry in getMapEntrySet(fieldElementsMap)) {
-      if (entry.getValue() == INIT_STATE.NOT_INIT) {
-        FieldElement fieldElement = entry.getKey();
+    for (MapIterator<FieldElement, INIT_STATE> iter = SingleMapIterator.forMap(fieldElementsMap); iter.moveNext();) {
+      if (iter.value == INIT_STATE.NOT_INIT) {
+        FieldElement fieldElement = iter.key;
         if (fieldElement.isConst) {
           _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_NOT_INITIALIZED, node.returnType, [fieldElement.name]);
           foundError = true;
         } else if (fieldElement.isFinal) {
           _errorReporter.reportErrorForNode(StaticWarningCode.FINAL_NOT_INITIALIZED, node.returnType, [fieldElement.name]);
           foundError = true;
         }
       }
     }
     return foundError;
@@ skipping 153 matching lines @@
       if (!overridingPositionalPT[i].isAssignableTo(overriddenPositionalPT[i])) {
         _errorReporter.reportErrorForNode(StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE, parameterLocations[parameterIndex], [
             overridingPositionalPT[i].displayName,
             overriddenPositionalPT[i].displayName,
             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()];
+    MapIterator<String, DartType> overriddenNamedPTIterator = SingleMapIterator.forMap(overriddenNamedPT);
+    while (overriddenNamedPTIterator.moveNext()) {
+      DartType overridingType = overridingNamedPT[overriddenNamedPTIterator.key];
       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)) {
+      if (!overriddenNamedPTIterator.value.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) {
+          if (parameter.parameterKind == ParameterKind.NAMED && overriddenNamedPTIterator.key == 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,
+              overriddenNamedPTIterator.value.displayName,
               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 317 matching lines @@
    */
   bool _checkForAmbiguousExport(ExportDirective node, ExportElement exportElement) {
     // prepare exported library
     LibraryElement exportedLibrary = exportElement.exportedLibrary;
     if (exportedLibrary == null) {
       return false;
     }
     // check exported names
     Namespace namespace = new NamespaceBuilder().createExportNamespaceForDirective(exportElement);
     Map<String, Element> definedNames = namespace.definedNames;
-    for (MapEntry<String, Element> definedEntry in getMapEntrySet(definedNames)) {
-      String name = definedEntry.getKey();
-      Element element = definedEntry.getValue();
+    for (MapIterator<String, Element> iter = SingleMapIterator.forMap(definedNames); iter.moveNext();) {
+      String name = iter.key;
+      Element element = iter.value;
       Element prevElement = _exportedElements[name];
       if (element != null && prevElement != null && prevElement != element) {
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.AMBIGUOUS_EXPORT, node, [
             name,
             prevElement.library.definingCompilationUnit.displayName,
             element.library.definingCompilationUnit.displayName]);
         return true;
       } else {
         _exportedElements[name] = element;
       }
@@ skipping 65 matching lines @@
    * @param expectedPropagatedType the expected propagated type, may be `null`
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    * @see CompileTimeErrorCode#LIST_ELEMENT_TYPE_NOT_ASSIGNABLE
    * @see StaticWarningCode#LIST_ELEMENT_TYPE_NOT_ASSIGNABLE
    * @see CompileTimeErrorCode#MAP_KEY_TYPE_NOT_ASSIGNABLE
    * @see CompileTimeErrorCode#MAP_VALUE_TYPE_NOT_ASSIGNABLE
    * @see StaticWarningCode#MAP_KEY_TYPE_NOT_ASSIGNABLE
    * @see StaticWarningCode#MAP_VALUE_TYPE_NOT_ASSIGNABLE
    */
-  bool _checkForArgumentTypeNotAssignableWithExpectedTypes(Expression expression, DartType expectedStaticType, ErrorCode errorCode) => _checkForArgumentTypeNotAssignable(expression, expectedStaticType, _getStaticType(expression), errorCode);
+  bool _checkForArgumentTypeNotAssignableWithExpectedTypes(Expression expression, DartType expectedStaticType, ErrorCode errorCode) => _checkForArgumentTypeNotAssignable(expression, expectedStaticType, getStaticType(expression), errorCode);
 
   /**
    * This verifies that the passed arguments can be assigned to their corresponding parameters.
    *
    * This method corresponds to BestPracticesVerifier.checkForArgumentTypesNotAssignableInList.
    *
    * @param node the arguments to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
@@ skipping 832 matching lines @@
     // OK, no default value.
     if (node.defaultValue == null) {
       return false;
     }
     // Report problem.
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER, node, []);
     return true;
   }
 
   /**
+   * This verifies that any deferred imports in the given compilation unit have a unique prefix.
+   *
+   * @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>>();
+      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];
+              if (elements == null) {
+                elements = new List<ImportDirective>();
+                prefixToDirectivesMap[prefixElement] = elements;
+              }
+              elements.add(importDirective);
+            }
+          }
+        }
+      }
+      for (List<ImportDirective> imports in prefixToDirectivesMap.values) {
+        if (_hasDeferredPrefixCollision(imports)) {
+          foundError = true;
+        }
+      }
+    }
+    return foundError;
+  }
+
+  /**
    * This verifies that the enclosing class does not have an instance member with the given name of
    * the static member.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#DUPLICATE_DEFINITION_INHERITANCE
    */
   bool _checkForDuplicateDefinitionInheritance() {
     if (_enclosingClass == null) {
       return false;
     }
@@ skipping 213 matching lines @@
     }
     FieldElement fieldElement = staticElement as FieldElement;
     // prepare field type
     DartType fieldType = fieldElement.type;
     // prepare expression type
     Expression expression = node.expression;
     if (expression == null) {
       return false;
     }
     // test the static type of the expression
-    DartType staticType = _getStaticType(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]);
     } else {
@@ skipping 353 matching lines @@
    *
    * @param lhs the left hand side expression
    * @param rhs the right hand side expression
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INVALID_ASSIGNMENT
    */
   bool _checkForInvalidAssignment(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return false;
     }
-    VariableElement leftElement = _getVariableElement(lhs);
-    DartType leftType = (leftElement == null) ? _getStaticType(lhs) : leftElement.type;
-    DartType staticRightType = _getStaticType(rhs);
-    bool isStaticAssignable = staticRightType.isAssignableTo(leftType);
-    if (!isStaticAssignable) {
+    VariableElement leftElement = getVariableElement(lhs);
+    DartType leftType = (leftElement == null) ? getStaticType(lhs) : leftElement.type;
+    DartType staticRightType = getStaticType(rhs);
+    if (!staticRightType.isAssignableTo(leftType)) {
       String leftName = leftType.displayName;
       String rightName = staticRightType.displayName;
       if (leftName == rightName) {
-        leftName = _getExtendedDisplayName(leftType);
-        rightName = _getExtendedDisplayName(staticRightType);
+        leftName = getExtendedDisplayName(leftType);
+        rightName = getExtendedDisplayName(staticRightType);
       }
       _errorReporter.reportErrorForNode(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [rightName, leftName]);
       return true;
     }
-    // TODO(brianwilkerson) Define a hint corresponding to the warning and report it if appropriate.
-    //    Type propagatedRightType = rhs.getPropagatedType();
-    //    boolean isPropagatedAssignable = propagatedRightType.isAssignableTo(leftType);
-    //    if (!isStaticAssignable && !isPropagatedAssignable) {
-    //      errorReporter.reportError(
-    //          StaticTypeWarningCode.INVALID_ASSIGNMENT,
-    //          rhs,
-    //          staticRightType.getDisplayName(),
-    //          leftType.getDisplayName());
-    //      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
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INVALID_ASSIGNMENT
    */
   bool _checkForInvalidCompoundAssignment(AssignmentExpression node) {
     Expression lhs = node.leftHandSide;
     if (lhs == null) {
       return false;
     }
-    VariableElement leftElement = _getVariableElement(lhs);
-    DartType leftType = (leftElement == null) ? _getStaticType(lhs) : leftElement.type;
+    VariableElement leftElement = getVariableElement(lhs);
+    DartType leftType = (leftElement == null) ? getStaticType(lhs) : leftElement.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) {
-        leftName = _getExtendedDisplayName(leftType);
-        rightName = _getExtendedDisplayName(rightType);
+        leftName = getExtendedDisplayName(leftType);
+        rightName = getExtendedDisplayName(rightType);
       }
       _errorReporter.reportErrorForNode(StaticTypeWarningCode.INVALID_ASSIGNMENT, node.rightHandSide, [rightName, leftName]);
       return true;
     }
     return false;
   }
 
   /**
    * Check the given initializer to ensure that the field being initialized is a valid field.
    *
@@ skipping 80 matching lines @@
     }
     // Check every list element.
     bool hasProblems = false;
     for (Expression element in node.elements) {
       hasProblems = javaBooleanOr(hasProblems, _checkForArgumentTypeNotAssignableWithExpectedTypes(element, listElementType, errorCode));
     }
     return hasProblems;
   }
 
   /**
+   * Check that the imported library does not define a loadLibrary function.
+   *
+   * @param node the import directive to evaluate
+   * @param importElement the [ImportElement] retrieved from the node
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION
+   */
+  bool _checkForLoadLibraryFunction(ImportDirective node, ImportElement importElement) {
+    LibraryElement importedLibrary = importElement.importedLibrary;
+    if (importedLibrary == null) {
+      return false;
+    }
+    if (importedLibrary.hasLoadLibraryFunction) {
+      _errorReporter.reportErrorForNode(CompileTimeErrorCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION, node, [importedLibrary.name]);
+      return true;
+    }
+    return false;
+  }
+
+  /**
    * This verifies that the key/value of entries of the given [MapLiteral] are subtypes of the
    * key/value types specified in the type arguments.
    *
    * @param node the map literal to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MAP_KEY_TYPE_NOT_ASSIGNABLE
    * @see CompileTimeErrorCode#MAP_VALUE_TYPE_NOT_ASSIGNABLE
    * @see StaticWarningCode#MAP_KEY_TYPE_NOT_ASSIGNABLE
    * @see StaticWarningCode#MAP_VALUE_TYPE_NOT_ASSIGNABLE
    */
@@ skipping 321 matching lines @@
     }
     // report problem
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT, node.name, [superType.displayName]);
     return true;
   }
 
   /**
    * This checks that passed class declaration overrides all members required by its superclasses
    * and interfaces.
    *
-   * @param node the [ClassDeclaration] to evaluate
+   * @param classNameNode the [SimpleIdentifier] to be used if there is a violation, this is
+   *          either the named from the [ClassDeclaration] or from the [ClassTypeAlias].
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS
    */
-  bool _checkForNonAbstractClassInheritsAbstractMember(ClassDeclaration node) {
+  bool _checkForNonAbstractClassInheritsAbstractMember(SimpleIdentifier classNameNode) {
     if (_enclosingClass.isAbstract) {
       return false;
     }
     //
     // Store in local sets the set of all method and accessor names
     //
     List<MethodElement> methods = _enclosingClass.methods;
-    List<PropertyAccessorElement> accessors = _enclosingClass.accessors;
-    Set<String> methodsInEnclosingClass = new Set<String>();
     for (MethodElement method in methods) {
       String methodName = method.name;
       // If the enclosing class declares the method noSuchMethod(), then return.
       // From Spec:  It is a static warning if a concrete class does not have an implementation for
       // a method in any of its superinterfaces unless it declares its own noSuchMethod
       // method (7.10).
       if (methodName == ElementResolver.NO_SUCH_METHOD_METHOD_NAME) {
         return false;
       }
-      methodsInEnclosingClass.add(methodName);
-    }
-    Set<String> accessorsInEnclosingClass = new Set<String>();
-    for (PropertyAccessorElement accessor in accessors) {
-      accessorsInEnclosingClass.add(accessor.name);
     }
     Set<ExecutableElement> missingOverrides = new Set<ExecutableElement>();
     //
     // Loop through the set of all executable elements declared in the implicit interface.
     //
     MemberMap membersInheritedFromInterfaces = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
     MemberMap membersInheritedFromSuperclasses = _inheritanceManager.getMapOfMembersInheritedFromClasses(_enclosingClass);
     for (int i = 0; i < membersInheritedFromInterfaces.size; i++) {
       String memberName = membersInheritedFromInterfaces.getKey(i);
       ExecutableElement executableElt = membersInheritedFromInterfaces.getValue(i);
@@ skipping 64 matching lines @@
       if (enclosingElement != null) {
         newStrMember = "${prefix}'${enclosingElement.displayName}.${missingOverridesArray[i].displayName}'";
       } else {
         newStrMember = "${prefix}'${missingOverridesArray[i].displayName}'";
       }
       stringMembersArrayListSet.add(newStrMember);
     }
     List<String> stringMembersArray = new List.from(stringMembersArrayListSet);
     AnalysisErrorWithProperties analysisError;
     if (stringMembersArray.length == 1) {
-      analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, node.name, [stringMembersArray[0]]);
+      analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, classNameNode, [stringMembersArray[0]]);
     } else if (stringMembersArray.length == 2) {
-      analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO, node.name, [stringMembersArray[0], stringMembersArray[1]]);
+      analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO, classNameNode, [stringMembersArray[0], stringMembersArray[1]]);
     } else if (stringMembersArray.length == 3) {
-      analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE, node.name, [
+      analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE, classNameNode, [
           stringMembersArray[0],
           stringMembersArray[1],
           stringMembersArray[2]]);
     } else if (stringMembersArray.length == 4) {
-      analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR, node.name, [
+      analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR, classNameNode, [
           stringMembersArray[0],
           stringMembersArray[1],
           stringMembersArray[2],
           stringMembersArray[3]]);
     } else {
-      analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS, node.name, [
+      analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS, classNameNode, [
           stringMembersArray[0],
           stringMembersArray[1],
           stringMembersArray[2],
           stringMembersArray[3],
           stringMembersArray.length - 4]);
     }
     analysisError.setProperty(ErrorProperty.UNIMPLEMENTED_METHODS, missingOverridesArray);
     _errorReporter.reportError(analysisError);
     return true;
   }
 
   /**
    * Checks to ensure that the expressions that need to be of type bool, are. Otherwise an error is
    * reported on the expression.
    *
    * @param condition the conditional expression to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#NON_BOOL_CONDITION
    */
   bool _checkForNonBoolCondition(Expression condition) {
-    DartType conditionType = _getStaticType(condition);
+    DartType conditionType = getStaticType(condition);
     if (conditionType != null && !conditionType.isAssignableTo(_boolType)) {
       _errorReporter.reportErrorForNode(StaticTypeWarningCode.NON_BOOL_CONDITION, condition, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed assert statement has either a 'bool' or '() -> bool' input.
    *
    * @param node the assert statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#NON_BOOL_EXPRESSION
    */
   bool _checkForNonBoolExpression(AssertStatement node) {
     Expression expression = node.condition;
-    DartType type = _getStaticType(expression);
+    DartType type = getStaticType(expression);
     if (type is InterfaceType) {
       if (!type.isAssignableTo(_boolType)) {
         _errorReporter.reportErrorForNode(StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression, []);
         return true;
       }
     } else if (type is FunctionType) {
       FunctionType functionType = type;
       if (functionType.typeArguments.length == 0 && !functionType.returnType.isAssignableTo(_boolType)) {
         _errorReporter.reportErrorForNode(StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Checks to ensure that the given expression is assignable to bool.
    *
    * @param expression the expression expression to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#NON_BOOL_NEGATION_EXPRESSION
    */
   bool _checkForNonBoolNegationExpression(Expression expression) {
-    DartType conditionType = _getStaticType(expression);
+    DartType conditionType = getStaticType(expression);
     if (conditionType != null && !conditionType.isAssignableTo(_boolType)) {
       _errorReporter.reportErrorForNode(StaticTypeWarningCode.NON_BOOL_NEGATION_EXPRESSION, expression, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies the passed map literal either:
    * * has `const modifier`
@@ skipping 322 matching lines @@
    *
    * This method is called both by [checkForAllReturnStatementErrorCodes]
    * and [visitExpressionFunctionBody].
    *
    * @param returnExpression the returned expression to evaluate
    * @param expectedReturnType the expressed return type by the enclosing method or function
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
    */
   bool _checkForReturnOfInvalidType(Expression returnExpression, DartType expectedReturnType) {
-    DartType staticReturnType = _getStaticType(returnExpression);
+    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,
           _enclosingFunction.displayName]);
       return true;
     }
@@ skipping 43 matching lines @@
    * This checks that the type of the passed 'switch' expression is assignable to the type of the
    * 'case' members.
    *
    * @param node the 'switch' statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#SWITCH_EXPRESSION_NOT_ASSIGNABLE
    */
   bool _checkForSwitchExpressionNotAssignable(SwitchStatement node) {
     // prepare 'switch' expression type
     Expression expression = node.expression;
-    DartType expressionType = _getStaticType(expression);
+    DartType expressionType = getStaticType(expression);
     if (expressionType == null) {
       return false;
     }
     // compare with type of the first 'case'
     NodeList<SwitchMember> members = node.members;
     for (SwitchMember switchMember in members) {
       if (switchMember is! SwitchCase) {
         continue;
       }
       SwitchCase switchCase = switchMember as SwitchCase;
       // prepare 'case' type
       Expression caseExpression = switchCase.expression;
-      DartType caseType = _getStaticType(caseExpression);
+      DartType caseType = getStaticType(caseExpression);
       // check types
       if (expressionType.isAssignableTo(caseType)) {
         return false;
       }
       // report problem
       _errorReporter.reportErrorForNode(StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE, expression, [expressionType, caseType]);
       return true;
     }
     return false;
   }
@@ skipping 376 matching lines @@
       if (interfaceNode.type == superType) {
         hasProblem = true;
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS, interfaceNode, [superType.displayName]);
       }
     }
     // done
     return hasProblem;
   }
 
   /**
-   * Return a display name for the given type that includes the path to the compilation unit in
-   * which the type is defined.
-   *
-   * @param type the type for which an extended display name is to be returned
-   * @return a display name that can help distiguish between two types with the same name
-   */
-  String _getExtendedDisplayName(DartType type) {
-    Element element = type.element;
-    if (element != null) {
-      Source source = element.source;
-      if (source != null) {
-        return "${type.displayName} (${source.fullName})";
-      }
-    }
-    return type.displayName;
-  }
-
-  /**
    * Returns the Type (return type) for a given getter.
    *
    * @param propertyAccessorElement
    * @return The type of the given getter.
    */
   DartType _getGetterType(PropertyAccessorElement propertyAccessorElement) {
     FunctionType functionType = propertyAccessorElement.type;
     if (functionType != null) {
       return functionType.returnType;
     } else {
@@ skipping 11 matching lines @@
     // Get the parameters for MethodDeclaration or FunctionDeclaration
     List<ParameterElement> setterParameters = propertyAccessorElement.parameters;
     // If there are no setter parameters, return no type.
     if (setterParameters.length == 0) {
       return null;
     }
     return setterParameters[0].type;
   }
 
   /**
-   * Return the static type of the given expression that is to be used for type analysis.
+   * Given a list of directives that have the same prefix, generate an error if there is more than
+   * one import and any of those imports is deferred.
    *
-   * @param expression the expression whose type is to be returned
-   * @return the static type of the given expression
+   * @param directives the list of directives that have the same prefix
+   * @return `true` if an error was generated
+   * @see CompileTimeErrorCode#SHARED_DEFERRED_PREFIX
    */
-  DartType _getStaticType(Expression expression) {
-    DartType type = expression.staticType;
-    if (type == null) {
-      // TODO(brianwilkerson) This should never happen.
-      return _dynamicType;
+  bool _hasDeferredPrefixCollision(List<ImportDirective> directives) {
+    bool foundError = false;
+    int count = directives.length;
+    if (count > 1) {
+      for (int i = 0; i < count; i++) {
+        sc.Token deferredToken = directives[i].deferredToken;
+        if (deferredToken != null) {
+          _errorReporter.reportErrorForToken(CompileTimeErrorCode.SHARED_DEFERRED_PREFIX, deferredToken, []);
+          foundError = true;
+        }
+      }
     }
-    return type;
+    return foundError;
   }
 
   /**
-   * Return the variable element represented by the given expression, or `null` if there is no
-   * such element.
-   *
-   * @param expression the expression whose element is to be returned
-   * @return the variable element represented by the expression
-   */
-  VariableElement _getVariableElement(Expression expression) {
-    if (expression is Identifier) {
-      Element element = expression.staticElement;
-      if (element is VariableElement) {
-        return element;
-      }
-    }
-    return null;
-  }
-
-  /**
    * @return `true` if the given constructor redirects to itself, directly or indirectly
    */
   bool _hasRedirectingFactoryConstructorCycle(ConstructorElement element) {
     Set<ConstructorElement> constructors = new Set<ConstructorElement>();
     ConstructorElement current = element;
     while (current != null) {
       if (constructors.contains(current)) {
         return identical(current, element);
       }
       constructors.add(current);
@@ skipping 74 matching lines @@
     } else if (type is InterfaceType) {
       MethodElement callMethod = type.lookUpMethod(ElementResolver.CALL_METHOD_NAME, _currentLibrary);
       return callMethod != null;
     }
     return false;
   }
 
   /**
    * Return `true` iff the passed [ClassElement] has a method, getter or setter that
    * matches the name of the passed [ExecutableElement] in either the class itself, or one of
-   * its' mixins.
+   * its' mixins that is concrete.
    *
    * By "match", only the name of the member is tested to match, it does not have to equal or be a
    * subtype of the passed executable element, this is due to the specific use where this method is
    * used in [checkForNonAbstractClassInheritsAbstractMember].
    *
    * @param executableElt the executable to search for in the passed class element
    * @param classElt the class method to search through the members of
    * @return `true` iff the passed member is found in the passed class element
    */
   bool _isMemberInClassOrMixin(ExecutableElement executableElt, ClassElement classElt) {
     ExecutableElement foundElt = null;
     String executableName = executableElt.name;
     if (executableElt is MethodElement) {
       foundElt = classElt.getMethod(executableName);
-      if (foundElt != null) {
+      if (foundElt != null && !(foundElt as MethodElement).isAbstract) {
         return true;
       }
       List<InterfaceType> mixins = classElt.mixins;
       for (int i = 0; i < mixins.length && foundElt == null; i++) {
         foundElt = mixins[i].getMethod(executableName);
       }
-      if (foundElt != null) {
+      if (foundElt != null && !(foundElt as MethodElement).isAbstract) {
         return true;
       }
     } else if (executableElt is PropertyAccessorElement) {
       PropertyAccessorElement propertyAccessorElement = executableElt;
       if (propertyAccessorElement.isGetter) {
         foundElt = classElt.getGetter(executableName);
       }
       if (foundElt == null && propertyAccessorElement.isSetter) {
         foundElt = classElt.getSetter(executableName);
       }
-      if (foundElt != null) {
+      if (foundElt != null && !(foundElt as PropertyAccessorElement).isAbstract) {
         return true;
       }
       List<InterfaceType> mixins = classElt.mixins;
       for (int i = 0; i < mixins.length && foundElt == null; i++) {
         foundElt = mixins[i].getGetter(executableName);
         if (foundElt == null) {
           foundElt = mixins[i].getSetter(executableName);
         }
       }
-      if (foundElt != null) {
+      if (foundElt != null && !(foundElt as PropertyAccessorElement).isAbstract) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * @param node the 'this' expression to analyze
    * @return `true` if the given 'this' expression is in the valid context
    */
@@ skipping 253 matching lines @@
    *
    * @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;
 }