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 46 matching lines @@
 
   static String _NG_ONE_WAY_ONE_TIME = "NgOneWayOneTime";
 
   static String _NG_TWO_WAY = "NgTwoWay";
 
   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 AngularElement
+    {
+      Element element = literal.toolkitElement;
+      if (element is AngularElement) {
+        return element;
+      }
+    }
     // prepare enclosing ClassDeclaration
     ClassDeclaration classDeclaration = node.getAncestor(ClassDeclaration);
     if (classDeclaration == null) {
       return null;
     }
     // prepare ClassElement
     ClassElement classElement = classDeclaration.element;
     if (classElement == null) {
       return null;
     }
     // check toolkit objects
     for (ToolkitObjectElement toolkitObject in classElement.toolkitObjects) {
       List<AngularPropertyElement> properties = AngularPropertyElement.EMPTY_ARRAY;
       // maybe name
       if (toolkitObject is AngularElement) {
         if (isNameCoveredByLiteral(toolkitObject, node)) {
           return toolkitObject;
         }
       }
+      // try selector
+      if (toolkitObject is AngularHasSelectorElement) {
+        AngularHasSelectorElement hasSelector = toolkitObject;
+        AngularSelectorElement selector = hasSelector.selector;
+        if (isNameCoveredByLiteral(selector, node)) {
+          return selector;
+        }
+      }
       // try properties of AngularComponentElement
       if (toolkitObject is AngularComponentElement) {
         AngularComponentElement component = toolkitObject;
-        // try selector
-        {
-          AngularSelectorElement selector = component.selector;
-          if (isNameCoveredByLiteral(selector, node)) {
-            return selector;
-          }
-        }
-        // try properties
         properties = component.properties;
       }
       // try properties of AngularDirectiveElement
       if (toolkitObject is AngularDirectiveElement) {
         AngularDirectiveElement directive = toolkitObject;
         properties = directive.properties;
       }
       // check properties
       for (AngularPropertyElement property in properties) {
         // property name (use complete node range)
@@ skipping 15 matching lines @@
     return null;
   }
 
   /**
    * Parses given selector text and returns [AngularSelectorElement]. May be `null` if
    * cannot parse.
    */
   static AngularSelectorElement parseSelector(int offset, String text) {
     // [attribute]
     if (StringUtilities.startsWithChar(text, 0x5B) && StringUtilities.endsWithChar(text, 0x5D)) {
-      int nameOffset = offset + "[".length;
+      int nameOffset = offset + 1;
       String attributeName = text.substring(1, text.length - 1);
       // TODO(scheglov) report warning if there are spaces between [ and identifier
       return new HasAttributeSelectorElementImpl(attributeName, nameOffset);
     }
+    // .class
+    if (StringUtilities.startsWithChar(text, 0x2E)) {
+      int nameOffset = offset + 1;
+      String className = text.substring(1, text.length);
+      return new AngularHasClassSelectorElementImpl(className, nameOffset);
+    }
     // tag[attribute]
     if (StringUtilities.endsWithChar(text, 0x5D)) {
       int index = StringUtilities.indexOf1(text, 0, 0x5B);
       if (index != -1) {
         String tagName = text.substring(0, index);
         String attributeName = text.substring(index + 1, text.length - 1);
         if (StringUtilities.isTagName(tagName)) {
           return new IsTagHasAttributeSelectorElementImpl(tagName, attributeName);
         }
       }
     }
     // tag
     if (StringUtilities.isTagName(text)) {
-      return new IsTagSelectorElementImpl(text, offset);
+      return new AngularTagSelectorElementImpl(text, offset);
     }
     return null;
   }
 
   /**
    * Returns the [FieldElement] of the first field in the given [FieldDeclaration].
    */
   static FieldElement getOnlyFieldElement(FieldDeclaration fieldDeclaration) {
     NodeList<VariableDeclaration> fields = fieldDeclaration.fields.variables;
     return fields[0].element as FieldElement;
@@ skipping 47 matching lines @@
    * The listener to which errors will be reported.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * The source containing the unit that will be analyzed.
    */
   Source _source;
 
   /**
+   * The compilation unit with built Dart element models.
+   */
+  CompilationUnit _unit;
+
+  /**
    * 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(AnalysisErrorListener errorListener, Source source) {
+  AngularCompilationUnitBuilder(AnalysisErrorListener errorListener, Source source, CompilationUnit unit) {
     this._errorListener = errorListener;
     this._source = source;
+    this._unit = unit;
   }
 
   /**
    * Builds Angular specific element models and adds them to the existing Dart elements.
-   *
-   * @param unit the compilation unit with built Dart element models
    */
-  void build(CompilationUnit unit) {
+  void build() {
+    parseViews();
     // process classes
-    for (CompilationUnitMember unitMember in unit.declarations) {
+    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;
@@ skipping 130 matching lines @@
       styleUriOffset = getStringArgumentOffset(_CSS_URL);
     }
     // 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(true);
+      element.properties = parseNgComponentProperties();
+      element.scopeProperties = parseScopeProperties();
       _classToolkitObjects.add(element);
     }
   }
 
   /**
    * Parses [AngularPropertyElement]s from [annotation] and [classDeclaration].
    */
-  List<AngularPropertyElement> parseNgComponentProperties(bool fromFields) {
+  List<AngularPropertyElement> parseNgComponentProperties() {
     List<AngularPropertyElement> properties = [];
     parseNgComponentProperties_fromMap(properties);
-    if (fromFields) {
-      parseNgComponentProperties_fromFields(properties);
-    }
+    parseNgComponentProperties_fromFields(properties);
     return new List.from(properties);
   }
 
   /**
    * Parses [AngularPropertyElement]s from [annotation].
    */
   void parseNgComponentProperties_fromFields(List<AngularPropertyElement> properties) {
     NodeList<ClassMember> members = _classDeclaration.members;
     for (ClassMember member in members) {
       if (member is FieldDeclaration) {
@@ skipping 145 matching lines @@
       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(false);
+      element.properties = parseNgComponentProperties();
       _classToolkitObjects.add(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));
     }
   }
 
+  List<AngularScopePropertyElement> parseScopeProperties() {
+    List<AngularScopePropertyElement> properties = [];
+    _classDeclaration.accept(new RecursiveASTVisitor_AngularCompilationUnitBuilder_parseScopeProperties(properties));
+    return new List.from(properties);
+  }
+
+  /**
+   * Create [AngularViewElement] for each valid <code>view('template.html')</code> invocation,
+   * where <code>view</code> is <code>ViewFactory</code>.
+   */
+  void parseViews() {
+    List<AngularViewElement> views = [];
+    _unit.accept(new RecursiveASTVisitor_AngularCompilationUnitBuilder_parseViews(views));
+    if (!views.isEmpty) {
+      List<AngularViewElement> viewArray = new List.from(views);
+      (_unit.element as CompilationUnitElementImpl).angularViews = viewArray;
+    }
+  }
+
   void reportError(ASTNode node, ErrorCode errorCode, List<Object> arguments) {
     int offset = node.offset;
     int length = node.length;
     reportError2(offset, length, errorCode, arguments);
   }
 
   void reportError2(int offset, int length, ErrorCode errorCode, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(_source, offset, length, errorCode, arguments));
   }
 
   void reportErrorForAnnotation(ErrorCode errorCode, List<Object> arguments) {
     reportError(_annotation, errorCode, arguments);
   }
 
   void reportErrorForArgument(String argumentName, ErrorCode errorCode, List<Object> arguments) {
     Expression argument = getArgument(argumentName);
     reportError(argument, errorCode, arguments);
   }
 }
 
+class RecursiveASTVisitor_AngularCompilationUnitBuilder_parseScopeProperties extends RecursiveASTVisitor<Object> {
+  List<AngularScopePropertyElement> properties;
+
+  RecursiveASTVisitor_AngularCompilationUnitBuilder_parseScopeProperties(this.properties) : super();
+
+  Object visitAssignmentExpression(AssignmentExpression node) {
+    addProperty(node);
+    return super.visitAssignmentExpression(node);
+  }
+
+  void addProperty(AssignmentExpression node) {
+    // try to find "name" in scope[name]
+    SimpleStringLiteral nameNode = getNameNode(node.leftHandSide);
+    if (nameNode == null) {
+      return;
+    }
+    // prepare unique
+    String name = nameNode.stringValue;
+    if (hasPropertyWithName(name)) {
+      return;
+    }
+    // do add property
+    int nameOffset = nameNode.valueOffset;
+    AngularScopePropertyElement property = new AngularScopePropertyElementImpl(name, nameOffset, node.rightHandSide.bestType);
+    nameNode.toolkitElement = property;
+    properties.add(property);
+  }
+
+  SimpleStringLiteral getNameNode(Expression node) {
+    if (node is IndexExpression) {
+      IndexExpression indexExpression = node;
+      Expression target = indexExpression.target;
+      Expression index = indexExpression.index;
+      if (index is SimpleStringLiteral && isContext(target)) {
+        return index;
+      }
+    }
+    return null;
+  }
+
+  bool hasPropertyWithName(String name) {
+    for (AngularScopePropertyElement property in properties) {
+      if (property.name == name) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool isContext(Expression target) {
+    if (target is PrefixedIdentifier) {
+      PrefixedIdentifier prefixed = target;
+      SimpleIdentifier prefix = prefixed.prefix;
+      SimpleIdentifier identifier = prefixed.identifier;
+      return (identifier.name == "context") && isScope(prefix);
+    }
+    return false;
+  }
+
+  bool isScope(Expression target) {
+    if (target != null) {
+      Type2 type = target.bestType;
+      if (type is InterfaceType) {
+        InterfaceType interfaceType = type;
+        return interfaceType.name == "Scope";
+      }
+    }
+    return false;
+  }
+}
+
+class RecursiveASTVisitor_AngularCompilationUnitBuilder_parseViews extends RecursiveASTVisitor<Object> {
+  List<AngularViewElement> views;
+
+  RecursiveASTVisitor_AngularCompilationUnitBuilder_parseViews(this.views) : super();
+
+  Object visitMethodInvocation(MethodInvocation node) {
+    addView(node);
+    return super.visitMethodInvocation(node);
+  }
+
+  void addView(MethodInvocation node) {
+    // only one argument
+    List<Expression> arguments = node.argumentList.arguments;
+    if (arguments.length != 1) {
+      return;
+    }
+    // String literal
+    Expression argument = arguments[0];
+    if (argument is! SimpleStringLiteral) {
+      return;
+    }
+    SimpleStringLiteral literal = argument as SimpleStringLiteral;
+    // just view('template')
+    if (node.realTarget != null) {
+      return;
+    }
+    // should be ViewFactory
+    if (!isViewFactory(node.methodName)) {
+      return;
+    }
+    // add AngularViewElement
+    String templateUri = literal.stringValue;
+    int templateUriOffset = literal.valueOffset;
+    views.add(new AngularViewElementImpl(templateUri, templateUriOffset));
+  }
+
+  bool isViewFactory(Expression target) {
+    if (target is SimpleIdentifier) {
+      SimpleIdentifier identifier = target;
+      Element element = identifier.staticElement;
+      if (element is VariableElement) {
+        VariableElement variable = element;
+        Type2 type = variable.type;
+        if (type is InterfaceType) {
+          InterfaceType interfaceType = type;
+          return interfaceType.name == "ViewFactory";
+        }
+      }
+    }
+    return false;
+  }
+}
+
 /**
  * Instances of the class `CompilationUnitBuilder` build an element model for a single
  * compilation unit.
  *
  * @coverage dart.engine.resolver
  */
 class CompilationUnitBuilder {
   /**
    * Build the compilation unit element for the given source.
    *
@@ skipping 186 matching lines @@
     _isValidMixin = false;
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     SimpleIdentifier constructorName = node.name;
-    ConstructorElementImpl element = new ConstructorElementImpl(constructorName);
+    ConstructorElementImpl element = new ConstructorElementImpl.con1(constructorName);
     if (node.factoryKeyword != null) {
       element.factory = true;
     }
     element.functions = holder.functions;
     element.labels = holder.labels;
     element.localVariables = holder.localVariables;
     element.parameters = holder.parameters;
     element.const2 = node.constKeyword != null;
     _currentHolder.addConstructor(element);
     node.element = element;
@@ skipping 478 matching lines @@
     }
   }
 
   /**
    * Creates the [ConstructorElement]s array with the single default constructor element.
    *
    * @param interfaceType the interface type for which to create a default constructor
    * @return the [ConstructorElement]s array with the single default constructor element
    */
   List<ConstructorElement> createDefaultConstructors(InterfaceTypeImpl interfaceType) {
-    ConstructorElementImpl constructor = new ConstructorElementImpl(null);
+    ConstructorElementImpl constructor = new ConstructorElementImpl.con1(null);
     constructor.synthetic = true;
     constructor.returnType = interfaceType;
     FunctionTypeImpl type = new FunctionTypeImpl.con1(constructor);
     _functionTypesToFix.add(type);
     constructor.type = type;
     return <ConstructorElement> [constructor];
   }
 
   /**
    * Create the types associated with the given type parameters, setting the type of each type
@@ skipping 507 matching lines @@
     this._errorListener = new RecordingErrorListener();
   }
 
   /**
    * Build the HTML element for the given source.
    *
    * @param source the source describing the compilation unit
    * @return the HTML element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
-  HtmlElementImpl buildHtmlElement(Source source) => buildHtmlElement2(source, source.modificationStamp, _context.parseHtmlUnit(source));
+  HtmlElementImpl buildHtmlElement(Source source) => buildHtmlElement2(source, _context.getModificationStamp(source), _context.parseHtmlUnit(source));
 
   /**
    * Build the HTML element for the given source.
    *
    * @param source the source describing the compilation unit
    * @param modificationStamp the modification time of the source for which an element is being
    *          built
    * @param unit the AST structure representing the HTML
    * @throws AnalysisException if the analysis could not be performed
    */
@@ skipping 48 matching lines @@
       } else {
         ExternalHtmlScriptElementImpl script = new ExternalHtmlScriptElementImpl(node);
         if (scriptSourcePath != null) {
           try {
             scriptSourcePath = Uri.encodeFull(scriptSourcePath);
             // Force an exception to be thrown if the URI is invalid so that we can report the
             // problem.
             parseUriWithException(scriptSourcePath);
             Source scriptSource = _context.sourceFactory.resolveUri(htmlSource, scriptSourcePath);
             script.scriptSource = scriptSource;
-            if (scriptSource == null || !scriptSource.exists()) {
+            if (!_context.exists(scriptSource)) {
               reportValueError(HtmlWarningCode.URI_DOES_NOT_EXIST, scriptAttribute, [scriptSourcePath]);
             }
           } on URISyntaxException catch (exception) {
             reportValueError(HtmlWarningCode.INVALID_URI, scriptAttribute, [scriptSourcePath]);
           }
         }
         node.scriptElement = script;
         _scripts.add(script);
       }
     } finally {
@@ skipping 918 matching lines @@
     }
   }
 }
 
 /**
  * Instances of the class `ExitDetector` determine whether the visited AST node is guaranteed
  * to terminate by executing a `return` statement, `throw` expression, `rethrow`
  * expression, or simple infinite loop such as `while(true)`.
  */
 class ExitDetector extends GeneralizingASTVisitor<bool> {
+  /**
+   * Set to `true` when a `break` is encountered, and reset to `false` when a
+   * `do`, `while`, `for` or `switch` block is entered.
+   */
+  bool _enclosingBlockContainsBreak = false;
+
   bool visitArgumentList(ArgumentList node) => visitExpressions(node.arguments);
 
   bool visitAsExpression(AsExpression node) => node.expression.accept(this);
 
   bool visitAssertStatement(AssertStatement node) => node.condition.accept(this);
 
   bool visitAssignmentExpression(AssignmentExpression node) => node.leftHandSide.accept(this) || node.rightHandSide.accept(this);
 
   bool visitBinaryExpression(BinaryExpression node) {
     Expression lhsExpression = node.leftOperand;
@@ skipping 20 matching lines @@
         }
       }
     }
     return lhsExpression.accept(this) || node.rightOperand.accept(this);
   }
 
   bool visitBlock(Block node) => visitStatements(node.statements);
 
   bool visitBlockFunctionBody(BlockFunctionBody node) => node.block.accept(this);
 
-  bool visitBreakStatement(BreakStatement node) => false;
+  bool visitBreakStatement(BreakStatement node) {
+    _enclosingBlockContainsBreak = true;
+    return false;
+  }
 
   bool visitCascadeExpression(CascadeExpression node) {
     Expression target = node.target;
     if (target.accept(this)) {
       return true;
     }
     return visitExpressions(node.cascadeSections);
   }
 
   bool visitConditionalExpression(ConditionalExpression node) {
     Expression conditionExpression = node.condition;
     Expression thenStatement = node.thenExpression;
     Expression elseStatement = node.elseExpression;
     // TODO(jwren) Do we want to take constant expressions into account, evaluate if(false) {}
     // differently than if(<condition>), when <condition> evaluates to a constant false value?
     if (conditionExpression.accept(this)) {
       return true;
     }
     if (thenStatement == null || elseStatement == null) {
       return false;
     }
     return thenStatement.accept(this) && elseStatement.accept(this);
   }
 
   bool visitContinueStatement(ContinueStatement node) => false;
 
   bool visitDoStatement(DoStatement node) {
-    Expression conditionExpression = node.condition;
-    if (conditionExpression.accept(this)) {
-      return true;
+    bool outerBreakValue = _enclosingBlockContainsBreak;
+    _enclosingBlockContainsBreak = false;
+    try {
+      Expression conditionExpression = node.condition;
+      if (conditionExpression.accept(this)) {
+        return true;
+      }
+      // TODO(jwren) Do we want to take all constant expressions into account?
+      if (conditionExpression is BooleanLiteral) {
+        BooleanLiteral booleanLiteral = conditionExpression;
+        // If do {} while (true), and the body doesn't return or the body doesn't have a break, then
+        // return true.
+        bool blockReturns = node.body.accept(this);
+        if (booleanLiteral.value && (blockReturns || !_enclosingBlockContainsBreak)) {
+          return true;
+        }
+      }
+      return false;
+    } finally {
+      _enclosingBlockContainsBreak = outerBreakValue;
     }
-    // TODO(jwren) Do we want to take all constant expressions into account?
-    if (conditionExpression is BooleanLiteral) {
-      BooleanLiteral booleanLiteral = conditionExpression;
-      if (booleanLiteral.value) {
-        return node.body.accept(this);
-      }
-    }
-    return false;
   }
 
   bool visitEmptyStatement(EmptyStatement node) => false;
 
   bool visitExpressionStatement(ExpressionStatement node) => node.expression.accept(this);
 
-  bool visitForEachStatement(ForEachStatement node) => node.iterator.accept(this);
+  bool visitForEachStatement(ForEachStatement node) {
+    bool outerBreakValue = _enclosingBlockContainsBreak;
+    _enclosingBlockContainsBreak = false;
+    try {
+      return node.iterator.accept(this);
+    } finally {
+      _enclosingBlockContainsBreak = outerBreakValue;
+    }
+  }
 
   bool visitForStatement(ForStatement node) {
-    if (node.variables != null && visitVariableDeclarations(node.variables.variables)) {
-      return true;
+    bool outerBreakValue = _enclosingBlockContainsBreak;
+    _enclosingBlockContainsBreak = false;
+    try {
+      if (node.variables != null && visitVariableDeclarations(node.variables.variables)) {
+        return true;
+      }
+      if (node.initialization != null && node.initialization.accept(this)) {
+        return true;
+      }
+      Expression conditionExpression = node.condition;
+      if (conditionExpression != null && conditionExpression.accept(this)) {
+        return true;
+      }
+      if (visitExpressions(node.updaters)) {
+        return true;
+      }
+      // TODO(jwren) Do we want to take all constant expressions into account?
+      // If for(; true; ) (or for(;;)), and the body doesn't return or the body doesn't have a
+      // break, then return true.
+      bool implicitOrExplictTrue = conditionExpression == null || (conditionExpression is BooleanLiteral && conditionExpression.value);
+      if (implicitOrExplictTrue) {
+        bool blockReturns = node.body.accept(this);
+        if (blockReturns || !_enclosingBlockContainsBreak) {
+          return true;
+        }
+      }
+      return false;
+    } finally {
+      _enclosingBlockContainsBreak = outerBreakValue;
     }
-    if (node.initialization != null && node.initialization.accept(this)) {
-      return true;
-    }
-    if (node.condition != null && node.condition.accept(this)) {
-      return true;
-    }
-    return visitExpressions(node.updaters);
   }
 
   bool visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => false;
 
   bool visitFunctionExpression(FunctionExpression node) => false;
 
   bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     if (node.function.accept(this)) {
       return true;
     }
@@ skipping 75 matching lines @@
 
   bool visitReturnStatement(ReturnStatement node) => true;
 
   bool visitSuperExpression(SuperExpression node) => false;
 
   bool visitSwitchCase(SwitchCase node) => visitStatements(node.statements);
 
   bool visitSwitchDefault(SwitchDefault node) => visitStatements(node.statements);
 
   bool visitSwitchStatement(SwitchStatement node) {
-    bool hasDefault = false;
-    NodeList<SwitchMember> memberList = node.members;
-    List<SwitchMember> members = new List.from(memberList);
-    for (int i = 0; i < members.length; i++) {
-      SwitchMember switchMember = members[i];
-      if (switchMember is SwitchDefault) {
-        hasDefault = true;
-        // If this is the last member and there are no statements, return false
-        if (switchMember.statements.isEmpty && i + 1 == members.length) {
+    bool outerBreakValue = _enclosingBlockContainsBreak;
+    _enclosingBlockContainsBreak = false;
+    try {
+      bool hasDefault = false;
+      NodeList<SwitchMember> memberList = node.members;
+      List<SwitchMember> members = new List.from(memberList);
+      for (int i = 0; i < members.length; i++) {
+        SwitchMember switchMember = members[i];
+        if (switchMember is SwitchDefault) {
+          hasDefault = true;
+          // If this is the last member and there are no statements, return false
+          if (switchMember.statements.isEmpty && i + 1 == members.length) {
+            return false;
+          }
+        }
+        // For switch members with no statements, don't visit the children, otherwise, return false if
+        // no return is found in the children statements
+        if (!switchMember.statements.isEmpty && !switchMember.accept(this)) {
           return false;
         }
       }
-      // For switch members with no statements, don't visit the children, otherwise, return false if
-      // no return is found in the children statements
-      if (!switchMember.statements.isEmpty && !switchMember.accept(this)) {
-        return false;
-      }
+      return hasDefault;
+    } finally {
+      _enclosingBlockContainsBreak = outerBreakValue;
     }
-    return hasDefault;
   }
 
   bool visitThisExpression(ThisExpression node) => false;
 
   bool visitThrowExpression(ThrowExpression node) => true;
 
   bool visitTryStatement(TryStatement node) {
     if (node.body.accept(this)) {
       return true;
     }
@@ skipping 20 matching lines @@
     NodeList<VariableDeclaration> variables = node.variables.variables;
     for (int i = 0; i < variables.length; i++) {
       if (variables[i].accept(this)) {
         return true;
       }
     }
     return false;
   }
 
   bool visitWhileStatement(WhileStatement node) {
-    Expression conditionExpression = node.condition;
-    if (conditionExpression.accept(this)) {
-      return true;
+    bool outerBreakValue = _enclosingBlockContainsBreak;
+    _enclosingBlockContainsBreak = false;
+    try {
+      Expression conditionExpression = node.condition;
+      if (conditionExpression.accept(this)) {
+        return true;
+      }
+      // TODO(jwren) Do we want to take all constant expressions into account?
+      if (conditionExpression is BooleanLiteral) {
+        BooleanLiteral booleanLiteral = conditionExpression;
+        // If while(true), and the body doesn't return or the body doesn't have a break, then return
+        // true.
+        bool blockReturns = node.body.accept(this);
+        if (booleanLiteral.value && (blockReturns || !_enclosingBlockContainsBreak)) {
+          return true;
+        }
+      }
+      return false;
+    } finally {
+      _enclosingBlockContainsBreak = outerBreakValue;
     }
-    // TODO(jwren) Do we want to take all constant expressions into account?
-    if (conditionExpression is BooleanLiteral) {
-      BooleanLiteral booleanLiteral = conditionExpression;
-      if (booleanLiteral.value) {
-        return node.body.accept(this);
-      }
-    }
-    return false;
   }
 
   bool visitExpressions(NodeList<Expression> expressions) {
     for (int i = expressions.length - 1; i >= 0; i--) {
       if (expressions[i].accept(this)) {
         return true;
       }
     }
     return false;
   }
@@ skipping 28 matching lines @@
   List<CompilationUnit> _compilationUnits;
 
   AnalysisContext _context;
 
   AnalysisErrorListener _errorListener;
 
   ImportsVerifier _importsVerifier;
 
   bool _enableDart2JSHints = false;
 
+  /**
+   * The inheritance manager used to find overridden methods.
+   */
+  InheritanceManager _manager;
+
   HintGenerator(List<CompilationUnit> compilationUnits, AnalysisContext context, AnalysisErrorListener errorListener) {
     this._compilationUnits = compilationUnits;
     this._context = context;
     this._errorListener = errorListener;
     LibraryElement library = compilationUnits[0].element.library;
     _importsVerifier = new ImportsVerifier(library);
     _enableDart2JSHints = context.analysisOptions.dart2jsHint;
+    _manager = new InheritanceManager(compilationUnits[0].element.library);
   }
 
   void generateForLibrary() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.hints.start();
     try {
       for (int i = 0; i < _compilationUnits.length; i++) {
         CompilationUnitElement element = _compilationUnits[i].element;
         if (element != null) {
           if (i == 0) {
             _importsVerifier.inDefiningCompilationUnit = true;
             generateForCompilationUnit(_compilationUnits[i], element.source);
             _importsVerifier.inDefiningCompilationUnit = false;
           } else {
             generateForCompilationUnit(_compilationUnits[i], element.source);
           }
         }
       }
       ErrorReporter definingCompilationUnitErrorReporter = new ErrorReporter(_errorListener, _compilationUnits[0].element.source);
       _importsVerifier.generateDuplicateImportHints(definingCompilationUnitErrorReporter);
       _importsVerifier.generateUnusedImportHints(definingCompilationUnitErrorReporter);
     } finally {
       timeCounter.stop();
     }
   }
 
   void generateForCompilationUnit(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
-    _importsVerifier.visitCompilationUnit(unit);
+    unit.accept(_importsVerifier);
     // dead code analysis
-    new DeadCodeVerifier(errorReporter).visitCompilationUnit(unit);
+    unit.accept(new DeadCodeVerifier(errorReporter));
     // dart2js analysis
     if (_enableDart2JSHints) {
-      new Dart2JSVerifier(errorReporter).visitCompilationUnit(unit);
+      unit.accept(new Dart2JSVerifier(errorReporter));
     }
     // Dart best practices
-    new BestPracticesVerifier(errorReporter).visitCompilationUnit(unit);
+    unit.accept(new BestPracticesVerifier(errorReporter));
+    unit.accept(new OverrideVerifier(_manager, errorReporter));
     // Find to-do comments
     new ToDoFinder(errorReporter).findIn(unit);
   }
 }
 
 /**
  * Instances of the class `ImportsVerifier` visit all of the referenced libraries in the
  * source code verifying that all of the imports are used, otherwise a
  * [HintCode#UNUSED_IMPORT] is generated with
  * [generateUnusedImportHints].
@@ skipping 326 matching lines @@
    */
   void visitMetadata(NodeList<Annotation> annotations) {
     for (Annotation annotation in annotations) {
       Identifier name = annotation.name;
       visitIdentifier(name.staticElement, name.name);
     }
   }
 }
 
 /**
+ * Instances of the class `OverrideVerifier` visit all of the declarations in a compilation
+ * unit to verify that if they have an override annotation it is being used correctly.
+ */
+class OverrideVerifier extends RecursiveASTVisitor<Object> {
+  /**
+   * The inheritance manager used to find overridden methods.
+   */
+  InheritanceManager _manager;
+
+  /**
+   * The error reporter used to report errors.
+   */
+  ErrorReporter _errorReporter;
+
+  /**
+   * Initialize a newly created verifier to look for inappropriate uses of the override annotation.
+   *
+   * @param manager the inheritance manager used to find overridden methods
+   * @param errorReporter the error reporter used to report errors
+   */
+  OverrideVerifier(InheritanceManager manager, ErrorReporter errorReporter) {
+    this._manager = manager;
+    this._errorReporter = errorReporter;
+  }
+
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement element = node.element;
+    if (isOverride(element)) {
+      if (getOverriddenMember(element) == null) {
+        if (element is MethodElement) {
+          _errorReporter.reportError3(HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD, node.name, []);
+        } else if (element is PropertyAccessorElement) {
+          if (element.isGetter) {
+            _errorReporter.reportError3(HintCode.OVERRIDE_ON_NON_OVERRIDING_GETTER, node.name, []);
+          } else {
+            _errorReporter.reportError3(HintCode.OVERRIDE_ON_NON_OVERRIDING_SETTER, node.name, []);
+          }
+        }
+      }
+    }
+    return super.visitMethodDeclaration(node);
+  }
+
+  /**
+   * Return the member that overrides the given member.
+   *
+   * @param member the member that overrides the returned member
+   * @return the member that overrides the given member
+   */
+  ExecutableElement getOverriddenMember(ExecutableElement member) {
+    LibraryElement library = member.library;
+    if (library == null) {
+      return null;
+    }
+    ClassElement classElement = member.getAncestor(ClassElement);
+    if (classElement == null) {
+      return null;
+    }
+    return _manager.lookupInheritance(classElement, member.name);
+  }
+
+  /**
+   * Return `true` if the given element has an override annotation associated with it.
+   *
+   * @param element the element being tested
+   * @return `true` if the element has an override annotation associated with it
+   */
+  bool isOverride(Element element) => element != null && element.isOverride;
+}
+
+/**
  * Instances of the class `PubVerifier` traverse an AST structure looking for deviations from
  * pub best practices.
  */
 class PubVerifier extends RecursiveASTVisitor<Object> {
   static String _PUBSPEC_YAML = "pubspec.yaml";
 
   /**
    * The analysis context containing the sources to be analyzed
    */
   AnalysisContext _context;
@@ skipping 30 matching lines @@
       int fullNameIndex = fullName.length;
       while (pathIndex < path.length && StringUtilities.startsWith3(path, pathIndex, 0x2E, 0x2E, 0x2F)) {
         fullNameIndex = JavaString.lastIndexOf(fullName, '/', fullNameIndex);
         if (fullNameIndex < 4) {
           return false;
         }
         // Check for "/lib" at a specified place in the fullName
         if (StringUtilities.startsWith4(fullName, fullNameIndex - 4, 0x2F, 0x6C, 0x69, 0x62)) {
           String relativePubspecPath = path.substring(0, pathIndex + 3) + _PUBSPEC_YAML;
           Source pubspecSource = _context.sourceFactory.resolveUri(source, relativePubspecPath);
-          if (pubspecSource != null && pubspecSource.exists()) {
+          if (_context.exists(pubspecSource)) {
             // Files inside the lib directory hierarchy should not reference files outside
             _errorReporter.reportError3(PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE, uriLiteral, []);
           }
           return true;
         }
         pathIndex += 3;
       }
     }
     return false;
   }
@@ skipping 21 matching lines @@
       }
       pathIndex = StringUtilities.indexOf5(path, pathIndex + 4, 0x2F, 0x6C, 0x69, 0x62, 0x2F);
     }
     return false;
   }
 
   bool checkForFileImportOutsideLibReferencesFileInside2(StringLiteral uriLiteral, String path, int pathIndex) {
     Source source = getSource(uriLiteral);
     String relativePubspecPath = path.substring(0, pathIndex) + _PUBSPEC_YAML;
     Source pubspecSource = _context.sourceFactory.resolveUri(source, relativePubspecPath);
-    if (pubspecSource == null || !pubspecSource.exists()) {
+    if (!_context.exists(pubspecSource)) {
       return false;
     }
     String fullName = getSourceFullName(source);
     if (fullName != null) {
       if (StringUtilities.indexOf5(fullName, 0, 0x2F, 0x6C, 0x69, 0x62, 0x2F) < 0) {
         // Files outside the lib directory hierarchy should not reference files inside
         // ... use package: url instead
         _errorReporter.reportError3(PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE, uriLiteral, []);
         return true;
       }
@@ skipping 1293 matching lines @@
  * names in hide and show combinators that are not defined in the imported library (which is not an
  * error).
  *
  * @coverage dart.engine.resolver
  */
 class ElementResolver extends SimpleASTVisitor<Object> {
   /**
    * Checks if the given expression is the reference to the type, if it is then the
    * [ClassElement] is returned, otherwise `null` is returned.
    *
-   * @param expr the expression to evaluate
+   * @param expression the expression to evaluate
    * @return the [ClassElement] if the given expression is the reference to the type, and
    *         `null` otherwise
    */
-  static ClassElementImpl getTypeReference(Expression expr) {
-    if (expr is Identifier) {
-      Identifier identifier = expr;
-      if (identifier.staticElement is ClassElementImpl) {
-        return identifier.staticElement as ClassElementImpl;
+  static ClassElementImpl getTypeReference(Expression expression) {
+    if (expression is Identifier) {
+      Element staticElement = expression.staticElement;
+      if (staticElement is ClassElementImpl) {
+        return staticElement;
       }
     }
     return null;
   }
 
   /**
+   * Return `true` if the given identifier is the return type of a constructor declaration.
+   *
    * @return `true` if the given identifier is the return type of a constructor declaration.
    */
-  static bool isConstructorReturnType(SimpleIdentifier node) {
-    ASTNode parent = node.parent;
+  static bool isConstructorReturnType(SimpleIdentifier identifier) {
+    ASTNode parent = identifier.parent;
     if (parent is ConstructorDeclaration) {
-      ConstructorDeclaration constructor = parent;
-      return identical(constructor.returnType, node);
+      return identical(parent.returnType, identifier);
     }
     return false;
   }
 
   /**
+   * Return `true` if the given identifier is the return type of a factory constructor.
+   *
    * @return `true` if the given identifier is the return type of a factory constructor
    *         declaration.
    */
   static bool isFactoryConstructorReturnType(SimpleIdentifier node) {
     ASTNode parent = node.parent;
     if (parent is ConstructorDeclaration) {
       ConstructorDeclaration constructor = parent;
       return identical(constructor.returnType, node) && constructor.factoryKeyword != null;
     }
     return false;
   }
 
   /**
-   * Checks if the given 'super' expression is used in the valid context.
+   * Return `true` if the given 'super' expression is used in a valid context.
    *
    * @param node the 'super' expression to analyze
-   * @return `true` if the given 'super' expression is in the valid context
+   * @return `true` if the 'super' expression is in a valid context
    */
   static bool isSuperInValidContext(SuperExpression node) {
     for (ASTNode n = node; n != null; n = n.parent) {
       if (n is CompilationUnit) {
         return false;
       }
       if (n is ConstructorDeclaration) {
         ConstructorDeclaration constructor = n as ConstructorDeclaration;
         return constructor.factoryKeyword == null;
       }
@@ skipping 78 matching lines @@
       operatorType = operatorFromCompoundAssignment(operatorType);
       Expression leftHandSide = node.leftHandSide;
       if (leftHandSide != null) {
         String methodName = operatorType.lexeme;
         Type2 staticType = getStaticType(leftHandSide);
         MethodElement staticMethod = lookUpMethod(leftHandSide, staticType, methodName);
         node.staticElement = staticMethod;
         Type2 propagatedType = getPropagatedType(leftHandSide);
         MethodElement propagatedMethod = lookUpMethod(leftHandSide, propagatedType, methodName);
         node.propagatedElement = propagatedMethod;
-        bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod);
-        bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
-        //
-        // If we are about to generate the hint (propagated version of this warning), then check
-        // that the member is not in a subtype of the propagated type.
-        //
-        if (shouldReportMissingMember_propagated) {
-          if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
-            shouldReportMissingMember_propagated = false;
-          }
-        }
-        if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
-          ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_METHOD : HintCode.UNDEFINED_METHOD) as ErrorCode;
-          _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
-              methodName,
-              shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
+        if (shouldReportMissingMember(staticType, staticMethod)) {
+          _resolver.reportErrorProxyConditionalAnalysisError3(staticType.element, StaticTypeWarningCode.UNDEFINED_METHOD, operator, [methodName, staticType.displayName]);
+        } else if (_enableHints && shouldReportMissingMember(propagatedType, propagatedMethod) && !memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
+          _resolver.reportErrorProxyConditionalAnalysisError3(propagatedType.element, HintCode.UNDEFINED_METHOD, operator, [methodName, propagatedType.displayName]);
         }
       }
     }
     return null;
   }
 
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     if (operator.isUserDefinableOperator) {
       Expression leftOperand = node.leftOperand;
       if (leftOperand != null) {
         String methodName = operator.lexeme;
         Type2 staticType = getStaticType(leftOperand);
         MethodElement staticMethod = lookUpMethod(leftOperand, staticType, methodName);
         node.staticElement = staticMethod;
         Type2 propagatedType = getPropagatedType(leftOperand);
         MethodElement propagatedMethod = lookUpMethod(leftOperand, propagatedType, methodName);
         node.propagatedElement = propagatedMethod;
-        bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod);
-        bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
-        //
-        // If we are about to generate the hint (propagated version of this warning), then check
-        // that the member is not in a subtype of the propagated type.
-        //
-        if (shouldReportMissingMember_propagated) {
-          if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
-            shouldReportMissingMember_propagated = false;
-          }
-        }
-        if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
-          ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
-          _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
-              methodName,
-              shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
+        if (shouldReportMissingMember(staticType, staticMethod)) {
+          _resolver.reportErrorProxyConditionalAnalysisError3(staticType.element, StaticTypeWarningCode.UNDEFINED_OPERATOR, operator, [methodName, staticType.displayName]);
+        } else if (_enableHints && shouldReportMissingMember(propagatedType, propagatedMethod) && !memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
+          _resolver.reportErrorProxyConditionalAnalysisError3(propagatedType.element, HintCode.UNDEFINED_OPERATOR, operator, [methodName, propagatedType.displayName]);
         }
       }
     }
     return null;
   }
 
   Object visitBreakStatement(BreakStatement node) {
-    SimpleIdentifier labelNode = node.label;
-    LabelElementImpl labelElement = lookupLabel(node, labelNode);
-    if (labelElement != null && labelElement.isOnSwitchMember) {
-      _resolver.reportError9(ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER, labelNode, []);
-    }
+    lookupLabel(node, node.label);
     return null;
   }
 
   Object visitClassDeclaration(ClassDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
 
   Object visitClassTypeAlias(ClassTypeAlias node) {
     setMetadata(node.element, node);
@@ skipping 80 matching lines @@
       }
     }
     return null;
   }
 
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
     ConstructorElement element = node.element;
     if (element is ConstructorElementImpl) {
       ConstructorElementImpl constructorElement = element;
-      // set redirected factory constructor
       ConstructorName redirectedNode = node.redirectedConstructor;
       if (redirectedNode != null) {
+        // set redirected factory constructor
         ConstructorElement redirectedElement = redirectedNode.staticElement;
         constructorElement.redirectedConstructor = redirectedElement;
-      }
-      // set redirected generate constructor
-      for (ConstructorInitializer initializer in node.initializers) {
-        if (initializer is RedirectingConstructorInvocation) {
-          ConstructorElement redirectedElement = initializer.staticElement;
-          constructorElement.redirectedConstructor = redirectedElement;
+      } else {
+        // set redirected generative constructor
+        for (ConstructorInitializer initializer in node.initializers) {
+          if (initializer is RedirectingConstructorInvocation) {
+            ConstructorElement redirectedElement = initializer.staticElement;
+            constructorElement.redirectedConstructor = redirectedElement;
+          }
         }
       }
       setMetadata(constructorElement, node);
     }
     return null;
   }
 
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     SimpleIdentifier fieldName = node.fieldName;
     ClassElement enclosingClass = _resolver.enclosingClass;
     FieldElement fieldElement = enclosingClass.getField(fieldName.name);
     fieldName.staticElement = fieldElement;
-    if (fieldElement == null || fieldElement.isSynthetic) {
-      _resolver.reportError9(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
-    } else if (fieldElement.isStatic) {
-      _resolver.reportError9(CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [fieldName]);
-    }
     return null;
   }
 
   Object visitConstructorName(ConstructorName node) {
     Type2 type = node.type.type;
     if (type != null && type.isDynamic) {
       return null;
     } else if (type is! InterfaceType) {
       // TODO(brianwilkerson) Report these errors.
-      ASTNode parent = node.parent;
-      if (parent is InstanceCreationExpression) {
-        if (parent.isConst) {
-        } else {
-        }
-      } else {
-      }
+      //      ASTNode parent = node.getParent();
+      //      if (parent instanceof InstanceCreationExpression) {
+      //        if (((InstanceCreationExpression) parent).isConst()) {
+      //          // CompileTimeErrorCode.CONST_WITH_NON_TYPE
+      //        } else {
+      //          // StaticWarningCode.NEW_WITH_NON_TYPE
+      //        }
+      //      } else {
+      //        // This is part of a redirecting factory constructor; not sure which error code to use
+      //      }
       return null;
     }
     // look up ConstructorElement
     ConstructorElement constructor;
     SimpleIdentifier name = node.name;
     InterfaceType interfaceType = type as InterfaceType;
     if (name == null) {
       constructor = interfaceType.lookUpConstructor(null, _definingLibrary);
     } else {
       constructor = interfaceType.lookUpConstructor(name.name, _definingLibrary);
       name.staticElement = constructor;
     }
     node.staticElement = constructor;
     return null;
   }
 
   Object visitContinueStatement(ContinueStatement node) {
-    SimpleIdentifier labelNode = node.label;
-    LabelElementImpl labelElement = lookupLabel(node, labelNode);
-    if (labelElement != null && labelElement.isOnSwitchStatement) {
-      _resolver.reportError9(ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode, []);
-    }
+    lookupLabel(node, node.label);
     return null;
   }
 
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     setMetadata(node.element, node);
     return null;
   }
 
   Object visitExportDirective(ExportDirective node) {
     Element element = node.element;
     if (element is ExportElement) {
       // The element is null when the URI is invalid
       // TODO(brianwilkerson) Figure out whether the element can ever be something other than an
       // ExportElement
       resolveCombinators(element.exportedLibrary, node.combinators);
       setMetadata(element, node);
     }
     return null;
   }
 
   Object visitFieldFormalParameter(FieldFormalParameter node) {
-    String fieldName = node.identifier.name;
-    ClassElement classElement = _resolver.enclosingClass;
-    if (classElement != null) {
-      FieldElement fieldElement = classElement.getField(fieldName);
-      if (fieldElement == null || fieldElement.isSynthetic) {
-        _resolver.reportError9(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
-      } else {
-        ParameterElement parameterElement = node.element;
-        if (parameterElement is FieldFormalParameterElementImpl) {
-          FieldFormalParameterElementImpl fieldFormal = parameterElement;
-          Type2 declaredType = fieldFormal.type;
-          Type2 fieldType = fieldElement.type;
-          if (fieldElement.isSynthetic) {
-            _resolver.reportError9(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
-          } else if (fieldElement.isStatic) {
-            _resolver.reportError9(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
-          } else if (declaredType != null && fieldType != null && !declaredType.isAssignableTo(fieldType)) {
-            _resolver.reportError9(StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE, node, [declaredType.displayName, fieldType.displayName]);
-          }
-        } else {
-          if (fieldElement.isSynthetic) {
-            _resolver.reportError9(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
-          } else if (fieldElement.isStatic) {
-            _resolver.reportError9(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
-          }
-        }
-      }
-    }
-    //    else {
-    //    // TODO(jwren) Report error, constructor initializer variable is a top level element
-    //    // (Either here or in ErrorVerifier#checkForAllFinalInitializedErrorCodes)
-    //    }
     setMetadata2(node.element, node);
     return super.visitFieldFormalParameter(node);
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
 
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
@@ skipping 259 matching lines @@
 
   Object visitPostfixExpression(PostfixExpression node) {
     Expression operand = node.operand;
     String methodName = getPostfixOperator(node);
     Type2 staticType = getStaticType(operand);
     MethodElement staticMethod = lookUpMethod(operand, staticType, methodName);
     node.staticElement = staticMethod;
     Type2 propagatedType = getPropagatedType(operand);
     MethodElement propagatedMethod = lookUpMethod(operand, propagatedType, methodName);
     node.propagatedElement = propagatedMethod;
-    bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod);
-    bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
-    //
-    // If we are about to generate the hint (propagated version of this warning), then check
-    // that the member is not in a subtype of the propagated type.
-    //
-    if (shouldReportMissingMember_propagated) {
-      if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
-        shouldReportMissingMember_propagated = false;
-      }
-    }
-    if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
-      ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
-      _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, node.operator, [
-          methodName,
-          shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
+    if (shouldReportMissingMember(staticType, staticMethod)) {
+      _resolver.reportErrorProxyConditionalAnalysisError3(staticType.element, StaticTypeWarningCode.UNDEFINED_OPERATOR, node.operator, [methodName, staticType.displayName]);
+    } else if (_enableHints && shouldReportMissingMember(propagatedType, propagatedMethod) && !memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
+      _resolver.reportErrorProxyConditionalAnalysisError3(propagatedType.element, HintCode.UNDEFINED_OPERATOR, node.operator, [methodName, propagatedType.displayName]);
     }
     return null;
   }
 
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefix = node.prefix;
     SimpleIdentifier identifier = node.identifier;
     //
     // First, check to see whether the prefix is really a prefix.
     //
@@ skipping 53 matching lines @@
     sc.TokenType operatorType = operator.type;
     if (operatorType.isUserDefinableOperator || identical(operatorType, sc.TokenType.PLUS_PLUS) || identical(operatorType, sc.TokenType.MINUS_MINUS)) {
       Expression operand = node.operand;
       String methodName = getPrefixOperator(node);
       Type2 staticType = getStaticType(operand);
       MethodElement staticMethod = lookUpMethod(operand, staticType, methodName);
       node.staticElement = staticMethod;
       Type2 propagatedType = getPropagatedType(operand);
       MethodElement propagatedMethod = lookUpMethod(operand, propagatedType, methodName);
       node.propagatedElement = propagatedMethod;
-      bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod);
-      bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
-      //
-      // If we are about to generate the hint (propagated version of this warning), then check
-      // that the member is not in a subtype of the propagated type.
-      //
-      if (shouldReportMissingMember_propagated) {
-        if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
-          shouldReportMissingMember_propagated = false;
-        }
-      }
-      if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
-        ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
-        _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
-            methodName,
-            shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
+      if (shouldReportMissingMember(staticType, staticMethod)) {
+        _resolver.reportErrorProxyConditionalAnalysisError3(staticType.element, StaticTypeWarningCode.UNDEFINED_OPERATOR, operator, [methodName, staticType.displayName]);
+      } else if (_enableHints && shouldReportMissingMember(propagatedType, propagatedMethod) && !memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
+        _resolver.reportErrorProxyConditionalAnalysisError3(propagatedType.element, HintCode.UNDEFINED_OPERATOR, operator, [methodName, propagatedType.displayName]);
       }
     }
     return null;
   }
 
   Object visitPropertyAccess(PropertyAccess node) {
     Expression target = node.realTarget;
     if (target is SuperExpression && !isSuperInValidContext(target)) {
       return null;
     }
@@ skipping 256 matching lines @@
    * [StaticWarningCode#UNDEFINED_OPERATOR] is generated.
    *
    * @param node the index expression to resolve
    * @param target the target of the expression
    * @param methodName the name of the operator associated with the context of using of the given
    *          index expression
    * @return `true` if and only if an error code is generated on the passed node
    */
   bool checkForUndefinedIndexOperator(IndexExpression node, Expression target, String methodName, MethodElement staticMethod, MethodElement propagatedMethod, Type2 staticType, Type2 propagatedType) {
     bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod);
-    bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
-    //
-    // If we are about to generate the hint (propagated version of this warning), then check
-    // that the member is not in a subtype of the propagated type.
-    //
-    if (shouldReportMissingMember_propagated) {
-      if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
-        shouldReportMissingMember_propagated = false;
-      }
-    }
+    bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints && shouldReportMissingMember(propagatedType, propagatedMethod) && !memberFoundInSubclass(propagatedType.element, methodName, true, false);
     if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
       sc.Token leftBracket = node.leftBracket;
       sc.Token rightBracket = node.rightBracket;
       ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
       if (leftBracket == null || rightBracket == null) {
         _resolver.reportErrorProxyConditionalAnalysisError(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, node, [
             methodName,
             shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
       } else {
         int offset = leftBracket.offset;
@@ skipping 624 matching lines @@
       } else if (operator == sc.TokenType.PERCENT_EQ) {
         return sc.TokenType.PERCENT;
       } else if (operator == sc.TokenType.PLUS_EQ) {
         return sc.TokenType.PLUS;
       } else if (operator == sc.TokenType.SLASH_EQ) {
         return sc.TokenType.SLASH;
       } else if (operator == sc.TokenType.STAR_EQ) {
         return sc.TokenType.STAR;
       } else if (operator == sc.TokenType.TILDE_SLASH_EQ) {
         return sc.TokenType.TILDE_SLASH;
+      } else {
+        // Internal error: Unmapped assignment operator.
+        AnalysisEngine.instance.logger.logError("Failed to map ${operator.lexeme} to it's corresponding operator");
+        return operator;
       }
       break;
     }
-    // Internal error: Unmapped assignment operator.
-    AnalysisEngine.instance.logger.logError("Failed to map ${operator.lexeme} to it's corresponding operator");
-    return operator;
   }
 
   void resolveAnnotationConstructorInvocationArguments(Annotation annotation, ConstructorElement constructor) {
     ArgumentList argumentList = annotation.arguments;
     // error will be reported in ConstantVerifier
     if (argumentList == null) {
       return;
     }
     // resolve arguments to parameters
     List<ParameterElement> parameters = resolveArgumentsToParameters(true, argumentList, constructor);
@@ skipping 752 matching lines @@
 }
 
 /**
  * Instances of the class `InheritanceManager` manage the knowledge of where class members
  * (methods, getters & setters) are inherited from.
  *
  * @coverage dart.engine.resolver
  */
 class InheritanceManager {
   /**
+   * Given some array of [ExecutableElement]s, this method creates a synthetic element as
+   * described in the Superinterfaces section of Inheritance and Overriding.
+   *
+   * TODO (jwren) Copy contents from the Spec into this javadoc.
+   *
+   * TODO (jwren) Associate a propagated type to the synthetic method element using least upper
+   * bound calls
+   */
+  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
+   * @param numOfPositionalParameters the number of positional parameters
+   * @param namedParameters the list of [String]s that are the named parameters
+   * @return the created synthetic element
+   */
+  static ExecutableElement createSyntheticExecutableElement(List<ExecutableElement> elementArrayToMerge, String name, int numOfRequiredParameters, int numOfPositionalParameters, List<String> namedParameters) {
+    DynamicTypeImpl dynamicType = DynamicTypeImpl.instance;
+    SimpleIdentifier nameIdentifier = new SimpleIdentifier(new sc.StringToken(sc.TokenType.IDENTIFIER, name, 0));
+    ExecutableElementImpl executable;
+    if (elementArrayToMerge[0] is MethodElement) {
+      MultiplyInheritedMethodElementImpl unionedMethod = new MultiplyInheritedMethodElementImpl(nameIdentifier);
+      unionedMethod.inheritedElements = elementArrayToMerge;
+      executable = unionedMethod;
+    } else {
+      MultiplyInheritedPropertyAccessorElementImpl unionedPropertyAccessor = new MultiplyInheritedPropertyAccessorElementImpl(nameIdentifier);
+      unionedPropertyAccessor.getter = (elementArrayToMerge[0] as PropertyAccessorElement).isGetter;
+      unionedPropertyAccessor.setter = (elementArrayToMerge[0] as PropertyAccessorElement).isSetter;
+      unionedPropertyAccessor.inheritedElements = elementArrayToMerge;
+      executable = unionedPropertyAccessor;
+    }
+    int numOfParameters = numOfRequiredParameters + numOfPositionalParameters + namedParameters.length;
+    List<ParameterElement> parameters = new List<ParameterElement>(numOfParameters);
+    int i = 0;
+    for (int j = 0; j < numOfRequiredParameters; j++, i++) {
+      ParameterElementImpl parameter = new ParameterElementImpl.con2("", 0);
+      parameter.type = dynamicType;
+      parameter.parameterKind = ParameterKind.REQUIRED;
+      parameters[i] = parameter;
+    }
+    for (int k = 0; k < numOfPositionalParameters; k++, i++) {
+      ParameterElementImpl parameter = new ParameterElementImpl.con2("", 0);
+      parameter.type = dynamicType;
+      parameter.parameterKind = ParameterKind.POSITIONAL;
+      parameters[i] = parameter;
+    }
+    for (int m = 0; m < namedParameters.length; m++, i++) {
+      ParameterElementImpl parameter = new ParameterElementImpl.con2(namedParameters[m], 0);
+      parameter.type = dynamicType;
+      parameter.parameterKind = ParameterKind.NAMED;
+      parameters[i] = parameter;
+    }
+    executable.returnType = dynamicType;
+    executable.parameters = parameters;
+    FunctionTypeImpl methodType = new FunctionTypeImpl.con1(executable);
+    executable.type = methodType;
+    return executable;
+  }
+
+  /**
+   * Given some [ExecutableElement], return the list of named parameters.
+   */
+  static List<String> getNamedParameterNames(ExecutableElement executableElement) {
+    List<String> namedParameterNames = new List<String>();
+    List<ParameterElement> parameters = executableElement.parameters;
+    for (int i = 0; i < parameters.length; i++) {
+      ParameterElement parameterElement = parameters[i];
+      if (identical(parameterElement.parameterKind, ParameterKind.NAMED)) {
+        namedParameterNames.add(parameterElement.name);
+      }
+    }
+    return namedParameterNames;
+  }
+
+  /**
+   * Given some [ExecutableElement] return the number of parameters of the specified kind.
+   */
+  static int getNumOfParameters(ExecutableElement executableElement, ParameterKind parameterKind) {
+    int parameterCount = 0;
+    List<ParameterElement> parameters = executableElement.parameters;
+    for (int i = 0; i < parameters.length; i++) {
+      ParameterElement parameterElement = parameters[i];
+      if (identical(parameterElement.parameterKind, parameterKind)) {
+        parameterCount++;
+      }
+    }
+    return parameterCount;
+  }
+
+  /**
+   * Given some [ExecutableElement] return the number of positional parameters.
+   *
+   * Note: by positional we mean [ParameterKind#REQUIRED] or [ParameterKind#POSITIONAL].
+   */
+  static int getNumOfPositionalParameters(ExecutableElement executableElement) => getNumOfParameters(executableElement, ParameterKind.REQUIRED) + getNumOfParameters(executableElement, ParameterKind.POSITIONAL);
+
+  /**
+   * Given some [ExecutableElement] return the number of required parameters.
+   */
+  static int getNumOfRequiredParameters(ExecutableElement executableElement) => getNumOfParameters(executableElement, ParameterKind.REQUIRED);
+
+  /**
    * 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;
 
@@ skipping 194 matching lines @@
       //
       // Include the members from the superclass in the resultMap
       //
       recordMapWithClassMembers(resultMap, supertype);
     }
     //
     // Include the members from the mixins in the resultMap
     //
     List<InterfaceType> mixins = classElt.mixins;
     for (int i = mixins.length - 1; i >= 0; i--) {
-      recordMapWithClassMembers(resultMap, mixins[i]);
+      recordMapWithClassMembersFromMixin(resultMap, mixins[i]);
     }
     _classLookup[classElt] = resultMap;
     return resultMap;
   }
 
   /**
    * Compute and return the inheritance path given the context of a type and a member that is
    * overridden in the inheritance path (for which the type is in the path).
    *
    * @param chain the inheritance path that is built up as this method calls itself recursively,
@@ skipping 147 matching lines @@
             return resultMap;
           }
         }
       }
     }
     if (lookupMaps.length == 0) {
       _interfaceLookup[classElt] = resultMap;
       return resultMap;
     }
     //
-    // Union all of the maps together, grouping the ExecutableElements into sets.
+    // 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, Set<ExecutableElement>> unionMap = new Map<String, Set<ExecutableElement>>();
+    Map<String, List<ExecutableElement>> unionMap = new Map<String, List<ExecutableElement>>();
     for (MemberMap lookupMap in lookupMaps) {
-      for (int i = 0; i < lookupMap.size; i++) {
+      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;
         }
-        Set<ExecutableElement> set = unionMap[key];
-        if (set == null) {
-          set = new Set<ExecutableElement>();
-          unionMap[key] = set;
+        // 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;
         }
-        set.add(lookupMap.getValue(i));
+        // 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 (identical(isMethod1, isMethod2) && executableElementInList.type == newExecutableElementEntry.type) {
+              alreadyInList = true;
+              break;
+            }
+          }
+          if (!alreadyInList) {
+            list.add(newExecutableElementEntry);
+          }
+        }
       }
     }
     //
-    // Loop through the entries in the union map, adding them to the resultMap appropriately.
+    // Loop through the entries in the unionMap, adding them to the resultMap appropriately.
     //
-    for (MapEntry<String, Set<ExecutableElement>> entry in getMapEntrySet(unionMap)) {
+    for (MapEntry<String, List<ExecutableElement>> entry in getMapEntrySet(unionMap)) {
       String key = entry.getKey();
-      Set<ExecutableElement> set = entry.getValue();
-      int numOfEltsWithMatchingNames = set.length;
+      List<ExecutableElement> list = entry.getValue();
+      int numOfEltsWithMatchingNames = list.length;
       if (numOfEltsWithMatchingNames == 1) {
-        resultMap.put(key, new JavaIterator(set).next());
+        //
+        // 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 {
+        //
+        // Then numOfEltsWithMatchingNames > 1, check for the warning cases.
+        //
         bool allMethods = true;
         bool allSetters = true;
         bool allGetters = true;
-        for (ExecutableElement executableElement in set) {
+        for (ExecutableElement executableElement in list) {
           if (executableElement is PropertyAccessorElement) {
             allMethods = false;
             if (executableElement.isSetter) {
               allGetters = false;
             } else {
               allSetters = false;
             }
           } else {
             allGetters = false;
             allSetters = false;
           }
         }
+        //
+        // If there isn't a mixture of methods with getters, then continue, otherwise create a
+        // warning.
+        //
         if (allMethods || allGetters || allSetters) {
+          //
           // Compute the element whose type is the subtype of all of the other types.
-          List<ExecutableElement> elements = new List.from(set);
+          //
+          List<ExecutableElement> elements = new List.from(list);
           List<FunctionType> executableElementTypes = new List<FunctionType>(numOfEltsWithMatchingNames);
           for (int i = 0; i < numOfEltsWithMatchingNames; i++) {
             executableElementTypes[i] = elements[i].type;
           }
-          bool foundSubtypeOfAllTypes = false;
+          List<int> subtypesOfAllOtherTypesIndexes = new List<int>();
           for (int i = 0; i < numOfEltsWithMatchingNames; i++) {
             FunctionType subtype = executableElementTypes[i];
             if (subtype == null) {
               continue;
             }
             bool subtypeOfAllTypes = true;
             for (int j = 0; j < numOfEltsWithMatchingNames && subtypeOfAllTypes; j++) {
               if (i != j) {
                 if (!subtype.isSubtypeOf(executableElementTypes[j])) {
                   subtypeOfAllTypes = false;
                   break;
                 }
               }
             }
             if (subtypeOfAllTypes) {
-              foundSubtypeOfAllTypes = true;
-              resultMap.put(key, elements[i]);
-              break;
+              subtypesOfAllOtherTypesIndexes.add(i);
             }
           }
-          if (!foundSubtypeOfAllTypes) {
-            reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE, [key]);
+          //
+          // The following is split into three cases determined by the number of elements in subtypesOfAllOtherTypes
+          //
+          if (subtypesOfAllOtherTypesIndexes.length == 1) {
+            //
+            // Example: class A inherited only 2 method named 'm'. One has the function type
+            // '() -> dynamic' and one has the function type '([int]) -> dynamic'. Since the second
+            // method is a subtype of all the others, it is the inherited method.
+            // Tests: InheritanceManagerTest.test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_*
+            //
+            resultMap.put(key, elements[subtypesOfAllOtherTypesIndexes[0]]);
+          } else {
+            if (subtypesOfAllOtherTypesIndexes.isEmpty) {
+              //
+              // 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]);
+            } 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++) {
+                elementArrayToMerge[i] = elements[subtypesOfAllOtherTypesIndexes[i]];
+              }
+              ExecutableElement mergedExecutableElement = computeMergedExecutableElement(elementArrayToMerge);
+              if (mergedExecutableElement != null) {
+                resultMap.put(key, mergedExecutableElement);
+              }
+            }
           }
         } else {
-          if (!allMethods && !allGetters) {
-            reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD, [key]);
-          }
-          resultMap.remove(entry.getKey());
+          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
@@ skipping 36 matching lines @@
     }
     List<PropertyAccessorElement> accessors = type.accessors;
     for (PropertyAccessorElement accessor in accessors) {
       if (accessor.isAccessibleIn(_library) && !accessor.isStatic) {
         map.put(accessor.name, accessor);
       }
     }
   }
 
   /**
+   * Similar to [recordMapWithClassMembers], but only puts values
+   * into the map if the additional executable doesn't replace a concrete member with an abstract
+   * member, ex: NonErrorResolverTest.test_nonAbstractClassInheritsAbstractMemberOne_mixin_*()
+   *
+   * @param map some non-`null` map to put the methods and accessors from the passed
+   *          [ClassElement] into
+   * @param type the type that will be recorded into the passed map
+   */
+  void recordMapWithClassMembersFromMixin(MemberMap map, InterfaceType type) {
+    List<MethodElement> methods = type.methods;
+    for (MethodElement method in methods) {
+      if (method.isAccessibleIn(_library) && !method.isStatic) {
+        String methodName = method.name;
+        ExecutableElement elementInMap = map.get(methodName);
+        if (elementInMap == null || (elementInMap != null && !method.isAbstract)) {
+          map.put(methodName, method);
+        }
+      }
+    }
+    List<PropertyAccessorElement> accessors = type.accessors;
+    for (PropertyAccessorElement accessor in accessors) {
+      if (accessor.isAccessibleIn(_library) && !accessor.isStatic) {
+        String accessorName = accessor.name;
+        ExecutableElement elementInMap = map.get(accessorName);
+        if (elementInMap == null || (elementInMap != null && !accessor.isAbstract)) {
+          map.put(accessorName, 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
    */
@@ skipping 269 matching lines @@
     String uriContent = uriLiteral.stringValue.trim();
     _directiveUris[directive] = uriContent;
     uriContent = Uri.encodeFull(uriContent);
     if (directive is ImportDirective && uriContent.startsWith(_DART_EXT_SCHEME)) {
       _libraryElement.hasExtUri2 = true;
       return null;
     }
     try {
       parseUriWithException(uriContent);
       Source source = _analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
-      if (source == null || !source.exists()) {
+      if (!_analysisContext.exists(source)) {
         _errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
       }
       return source;
     } on URISyntaxException catch (exception) {
       _errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
     }
     return null;
   }
 
   /**
@@ skipping 58 matching lines @@
   InternalAnalysisContext _analysisContext;
 
   /**
    * The listener to which errors will be reported.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * The name of the function used as an entry point.
    */
-  static String _ENTRY_POINT_NAME = "main";
+  static String ENTRY_POINT_NAME = "main";
 
   /**
    * Initialize a newly created library element builder.
    *
    * @param resolver the resolver for which the element model is being built
    */
   LibraryElementBuilder(LibraryResolver resolver) {
     this._analysisContext = resolver.analysisContext;
     this._errorListener = resolver.errorListener;
   }
@@ skipping 25 matching lines @@
       //
       if (directive is LibraryDirective) {
         if (libraryNameNode == null) {
           libraryNameNode = directive.name;
           directivesToResolve.add(directive);
         }
       } else if (directive is PartDirective) {
         PartDirective partDirective = directive;
         StringLiteral partUri = partDirective.uri;
         Source partSource = library.getSource(partDirective);
-        if (partSource != null && partSource.exists()) {
+        if (_analysisContext.exists(partSource)) {
           hasPartDirective = true;
           CompilationUnitElementImpl part = builder.buildCompilationUnit(partSource, library.getAST(partSource));
           part.uri = library.getUri(partDirective);
           //
           // Validate that the part contains a part-of directive with the same name as the library.
           //
           String partLibraryName = getPartLibraryName(library, partSource, directivesToResolve);
           if (partLibraryName == null) {
             _errorListener.onError(new AnalysisError.con2(librarySource, partUri.offset, partUri.length, CompileTimeErrorCode.PART_OF_NON_PART, [partUri.toSource()]));
           } else if (libraryNameNode == null) {
@@ skipping 55 matching lines @@
 
   /**
    * Search the top-level functions defined in the given compilation unit for the entry point.
    *
    * @param element the compilation unit to be searched
    * @return the entry point that was found, or `null` if the compilation unit does not define
    *         an entry point
    */
   FunctionElement findEntryPoint(CompilationUnitElementImpl element) {
     for (FunctionElement function in element.functions) {
-      if (function.name == _ENTRY_POINT_NAME) {
+      if (function.name == ENTRY_POINT_NAME) {
         return function;
       }
     }
     return null;
   }
 
   /**
    * Return the name of the library that the given part is declared to be a part of, or `null`
    * if the part does not contain a part-of directive.
    *
@@ skipping 441 matching lines @@
       Source librarySource = library.librarySource;
       if (!library.explicitlyImportsCore && _coreLibrarySource != librarySource) {
         ImportElementImpl importElement = new ImportElementImpl(-1);
         importElement.importedLibrary = _coreLibrary.libraryElement;
         importElement.synthetic = true;
         imports.add(importElement);
       }
       LibraryElementImpl libraryElement = library.libraryElement;
       libraryElement.imports = new List.from(imports);
       libraryElement.exports = new List.from(exports);
+      if (libraryElement.entryPoint == null) {
+        Namespace namespace = new NamespaceBuilder().createExportNamespace2(libraryElement);
+        Element element = namespace.get(LibraryElementBuilder.ENTRY_POINT_NAME);
+        if (element is FunctionElement) {
+          libraryElement.entryPoint = element;
+        }
+      }
     }
   }
 
   /**
    * Build element models for all of the libraries in the current cycle.
    *
    * @throws AnalysisException if any of the element models cannot be built
    */
   void buildElementModels() {
     for (Library library in _librariesInCycles) {
@@ skipping 151 matching lines @@
   /**
    * Create an object to represent the information about the library defined by the compilation unit
    * with the given source.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @return the library object that was created
    * @throws AnalysisException if the library source is not valid
    */
   Library createLibrary(Source librarySource) {
     Library library = new Library(analysisContext, _errorListener, librarySource);
-    library.definingCompilationUnit;
     _libraryMap[librarySource] = library;
     return library;
   }
 
   /**
    * Create an object to represent the information about the library defined by the compilation unit
    * with the given source.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @param modificationStamp the modification time of the source from which the compilation unit
@@ skipping 11 matching lines @@
 
   /**
    * Create an object to represent the information about the library defined by the compilation unit
    * with the given source. Return the library object that was created, or `null` if the
    * source is not valid.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @return the library object that was created
    */
   Library createLibraryOrNull(Source librarySource) {
-    if (!librarySource.exists()) {
+    if (!analysisContext.exists(librarySource)) {
       return null;
     }
     Library library = new Library(analysisContext, _errorListener, librarySource);
     _libraryMap[librarySource] = library;
     return library;
   }
 
   /**
    * Return an array containing the lexical identifiers associated with the nodes in the given list.
    *
@@ skipping 68 matching lines @@
         }
       }
     } finally {
       timeCounter.stop();
     }
     // Angular
     timeCounter = PerformanceStatistics.angular.start();
     try {
       for (Source source in library.compilationUnitSources) {
         CompilationUnit ast = library.getAST(source);
-        new AngularCompilationUnitBuilder(_errorListener, source).build(ast);
+        new AngularCompilationUnitBuilder(_errorListener, source, 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.
    *
@@ skipping 182 matching lines @@
  * This class is a wrapper for an [AnalysisError] which can also be queried after resolution
  * to find out if the error should actually be reported. In this case, these errors are conditional
  * on the non-existence of an `@proxy` annotation.
  *
  * If we have other conditional error codes in the future, we should have this class implement some
  * ConditionalErrorCode so that after resolution, a list of ConditionalErrorCode can be visited
  * instead of multiple lists of *ConditionalErrorCodes.
  */
 class ProxyConditionalAnalysisError {
   /**
-   * Return `true` if the given element represents a class that has the proxy annotation.
-   *
-   * @param element the class being tested
-   * @return `true` if the given element represents a class that has the proxy annotation
-   */
-  static bool classHasProxyAnnotation(Element element) => (element is ClassElement) && element.isProxy;
-
-  /**
    * The enclosing [ClassElement], this is what will determine if the error code should, or
    * should not, be generated on the source.
    */
   Element _enclosingElement;
 
   /**
    * The conditional analysis error.
    */
   final AnalysisError analysisError;
 
   /**
-   * Instantiate a new ProxyConditionalErrorCode with some enclosing element and the conditional
-   * analysis error.
+   * Instantiate a new [ProxyConditionalAnalysisError] with some enclosing element and the
+   * conditional analysis error.
    *
    * @param enclosingElement the enclosing element
    * @param analysisError the conditional analysis error
    */
   ProxyConditionalAnalysisError(Element enclosingElement, this.analysisError) {
     this._enclosingElement = enclosingElement;
   }
 
   /**
    * Return `true` iff the enclosing class has the proxy annotation.
    *
    * @return `true` iff the enclosing class has the proxy annotation
    */
-  bool shouldIncludeErrorCode() => !classHasProxyAnnotation(_enclosingElement);
+  bool shouldIncludeErrorCode() {
+    if (_enclosingElement is ClassElement) {
+      return !(_enclosingElement as ClassElement).isOrInheritsProxy;
+    }
+    return true;
+  }
 }
 
 /**
  * Instances of the class `ResolverVisitor` are used to resolve the nodes within a single
  * compilation unit.
  *
  * @coverage dart.engine.resolver
  */
 class ResolverVisitor extends ScopedVisitor {
   /**
@@ skipping 4383 matching lines @@
   Object visitClassTypeAlias(ClassTypeAlias node) {
     super.visitClassTypeAlias(node);
     ClassElementImpl classElement = getClassElement(node.name);
     ErrorCode errorCode = CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS;
     InterfaceType superclassType = resolveType(node.superclass, errorCode, errorCode);
     if (superclassType == null) {
       superclassType = typeProvider.objectType;
     }
     if (classElement != null && superclassType != null) {
       classElement.supertype = superclassType;
+      ClassElement superclassElement = superclassType.element;
+      if (superclassElement != null) {
+        List<ConstructorElement> constructors = superclassElement.constructors;
+        int count = constructors.length;
+        if (count > 0) {
+          List<Type2> parameterTypes = TypeParameterTypeImpl.getTypes(superclassType.typeParameters);
+          List<Type2> argumentTypes = getArgumentTypes(node.superclass.typeArguments, parameterTypes);
+          InterfaceType classType = classElement.type;
+          List<ConstructorElement> implicitConstructors = new List<ConstructorElement>();
+          for (int i = 0; i < count; i++) {
+            ConstructorElement explicitConstructor = constructors[i];
+            if (!explicitConstructor.isFactory) {
+              implicitConstructors.add(createImplicitContructor(classType, explicitConstructor, parameterTypes, argumentTypes));
+            }
+          }
+          classElement.constructors = new List.from(implicitConstructors);
+        }
+      }
     }
     resolve(classElement, node.withClause, node.implementsClause);
     return null;
   }
 
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
     ClassElement definingClass = element.enclosingElement as ClassElement;
     element.returnType = definingClass.type;
@@ skipping 420 matching lines @@
    */
   Type2 computeReturnType(TypeName returnType) {
     if (returnType == null) {
       return _dynamicType;
     } else {
       return returnType.type;
     }
   }
 
   /**
+   * Create an implicit constructor that is copied from the given constructor, but that is in the
+   * given class.
+   *
+   * @param classType the class in which the implicit constructor is defined
+   * @param explicitConstructor the constructor on which the implicit constructor is modeled
+   * @param parameterTypes the types to be replaced when creating parameters
+   * @param argumentTypes the types with which the parameters are to be replaced
+   * @return the implicit constructor that was created
+   */
+  ConstructorElement createImplicitContructor(InterfaceType classType, ConstructorElement explicitConstructor, List<Type2> parameterTypes, List<Type2> argumentTypes) {
+    ConstructorElementImpl implicitConstructor = new ConstructorElementImpl.con2(explicitConstructor.name, -1);
+    implicitConstructor.synthetic = true;
+    implicitConstructor.redirectedConstructor = explicitConstructor;
+    implicitConstructor.const2 = explicitConstructor.isConst;
+    implicitConstructor.returnType = classType;
+    List<ParameterElement> explicitParameters = explicitConstructor.parameters;
+    int count = explicitParameters.length;
+    if (count > 0) {
+      List<ParameterElement> implicitParameters = new List<ParameterElement>(count);
+      for (int i = 0; i < count; i++) {
+        ParameterElement explicitParameter = explicitParameters[i];
+        ParameterElementImpl implicitParameter = new ParameterElementImpl.con2(explicitParameter.name, -1);
+        implicitParameter.const3 = explicitParameter.isConst;
+        implicitParameter.final2 = explicitParameter.isFinal;
+        implicitParameter.parameterKind = explicitParameter.parameterKind;
+        implicitParameter.synthetic = true;
+        implicitParameter.type = explicitParameter.type.substitute2(argumentTypes, parameterTypes);
+        implicitParameters[i] = implicitParameter;
+      }
+      implicitConstructor.parameters = implicitParameters;
+    }
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(implicitConstructor);
+    type.typeArguments = classType.typeArguments;
+    implicitConstructor.type = type;
+    return implicitConstructor;
+  }
+
+  /**
+   * Return an array of argument types that corresponds to the array of parameter types and that are
+   * derived from the given list of type arguments.
+   *
+   * @param typeArguments the type arguments from which the types will be taken
+   * @param parameterTypes the parameter types that must be matched by the type arguments
+   * @return the argument types that correspond to the parameter types
+   */
+  List<Type2> getArgumentTypes(TypeArgumentList typeArguments, List<Type2> parameterTypes) {
+    DynamicTypeImpl dynamic = DynamicTypeImpl.instance;
+    int parameterCount = parameterTypes.length;
+    List<Type2> types = new List<Type2>(parameterCount);
+    if (typeArguments == null) {
+      for (int i = 0; i < parameterCount; i++) {
+        types[i] = dynamic;
+      }
+    } else {
+      NodeList<TypeName> arguments = typeArguments.arguments;
+      int argumentCount = Math.min(arguments.length, parameterCount);
+      for (int i = 0; i < argumentCount; i++) {
+        types[i] = arguments[i].type;
+      }
+      for (int i = argumentCount; i < parameterCount; i++) {
+        types[i] = dynamic;
+      }
+    }
+    return types;
+  }
+
+  /**
    * Return the class element that represents the class whose name was provided.
    *
    * @param identifier the name from the declaration of a class
    * @return the class element that represents the class
    */
   ClassElementImpl getClassElement(SimpleIdentifier identifier) {
     // TODO(brianwilkerson) Seems like we should be using ClassDeclaration.getElement().
     if (identifier == null) {
       // TODO(brianwilkerson) Report this
       // Internal error: We should never build a class declaration without a name.
@@ skipping 2084 matching lines @@
    */
   ClassElement _enclosingClass;
 
   /**
    * The method or function that we are currently visiting, or `null` if we are not inside a
    * method or function.
    */
   ExecutableElement _enclosingFunction;
 
   /**
-   * The number of return statements found in the method or function that we are currently visiting
-   * that have a return value.
+   * The return statements found in the method or function that we are currently visiting that have
+   * a return value.
    */
-  int _returnWithCount = 0;
+  List<ReturnStatement> _returnsWith = new List<ReturnStatement>();
 
   /**
-   * The number of return statements found in the method or function that we are currently visiting
-   * that do not have a return value.
+   * The return statements found in the method or function that we are currently visiting that do
+   * not have a return value.
    */
-  int _returnWithoutCount = 0;
+  List<ReturnStatement> _returnsWithout = new List<ReturnStatement>();
 
   /**
    * This map is initialized when visiting the contents of a class declaration. If the visitor is
    * not in an enclosing class declaration, then the map is set to `null`.
    *
    * 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
@@ skipping 82 matching lines @@
     checkForArgumentTypeNotAssignable2(node.rightHandSide);
     return super.visitAssignmentExpression(node);
   }
 
   Object visitBinaryExpression(BinaryExpression node) {
     checkForArgumentTypeNotAssignable2(node.rightOperand);
     return super.visitBinaryExpression(node);
   }
 
   Object visitBlockFunctionBody(BlockFunctionBody node) {
-    int previousReturnWithCount = _returnWithCount;
-    int previousReturnWithoutCount = _returnWithoutCount;
+    List<ReturnStatement> previousReturnsWith = _returnsWith;
+    List<ReturnStatement> previousReturnsWithout = _returnsWithout;
     try {
-      _returnWithCount = 0;
-      _returnWithoutCount = 0;
+      _returnsWith = new List<ReturnStatement>();
+      _returnsWithout = new List<ReturnStatement>();
       super.visitBlockFunctionBody(node);
       checkForMixedReturns(node);
     } finally {
-      _returnWithCount = previousReturnWithCount;
-      _returnWithoutCount = previousReturnWithoutCount;
+      _returnsWith = previousReturnsWith;
+      _returnsWithout = previousReturnsWithout;
     }
     return null;
   }
+
+  Object visitBreakStatement(BreakStatement node) {
+    SimpleIdentifier labelNode = node.label;
+    if (labelNode != null) {
+      Element labelElement = labelNode.staticElement;
+      if (labelElement is LabelElementImpl && labelElement.isOnSwitchMember) {
+        _errorReporter.reportError3(ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER, labelNode, []);
+      }
+    }
+    return null;
+  }
 
   Object visitCatchClause(CatchClause node) {
     bool previousIsInCatchClause = _isInCatchClause;
     try {
       _isInCatchClause = true;
       return super.visitCatchClause(node);
     } finally {
       _isInCatchClause = previousIsInCatchClause;
     }
   }
@@ skipping 92 matching lines @@
       return super.visitConstructorDeclaration(node);
     } finally {
       _isEnclosingConstructorConst = false;
       _enclosingFunction = outerFunction;
     }
   }
 
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     _isInConstructorInitializer = true;
     try {
+      checkForInvalidField(node);
       checkForFieldInitializerNotAssignable(node);
       return super.visitConstructorFieldInitializer(node);
     } finally {
       _isInConstructorInitializer = false;
     }
   }
 
+  Object visitContinueStatement(ContinueStatement node) {
+    SimpleIdentifier labelNode = node.label;
+    if (labelNode != null) {
+      Element labelElement = labelNode.staticElement;
+      if (labelElement is LabelElementImpl && labelElement.isOnSwitchStatement) {
+        _errorReporter.reportError3(ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode, []);
+      }
+    }
+    return null;
+  }
+
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     checkForInvalidAssignment2(node.identifier, node.defaultValue);
     checkForDefaultValueInFunctionTypedParameter(node);
     return super.visitDefaultFormalParameter(node);
   }
 
   Object visitDoStatement(DoStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitDoStatement(node);
   }
@@ skipping 15 matching lines @@
   Object visitFieldDeclaration(FieldDeclaration node) {
     if (!node.isStatic) {
       VariableDeclarationList variables = node.fields;
       if (variables.isConst) {
         _errorReporter.reportError6(CompileTimeErrorCode.CONST_INSTANCE_FIELD, variables.keyword, []);
       }
     }
     _isInStaticVariableDeclaration = node.isStatic;
     _isInInstanceVariableDeclaration = !_isInStaticVariableDeclaration;
     try {
-      checkForAllInvalidOverrideErrorCodes2(node);
+      checkForAllInvalidOverrideErrorCodes3(node);
       return super.visitFieldDeclaration(node);
     } finally {
       _isInStaticVariableDeclaration = false;
       _isInInstanceVariableDeclaration = false;
     }
   }
 
   Object visitFieldFormalParameter(FieldFormalParameter node) {
+    checkForValidField(node);
     checkForConstFormalParameter(node);
     checkForPrivateOptionalParameter(node);
     checkForFieldInitializingFormalRedirectingConstructor(node);
     return super.visitFieldFormalParameter(node);
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       SimpleIdentifier identifier = node.name;
@@ skipping 152 matching lines @@
         checkForNonVoidReturnTypeForSetter(node.returnType);
         checkForConflictingStaticSetterAndInstanceMember(node);
       } else if (node.isOperator) {
         checkForOptionalParameterInOperator(node);
         checkForWrongNumberOfParametersForOperator(node);
         checkForNonVoidReturnTypeForOperator(node);
       } else {
         checkForConflictingInstanceMethodSetter(node);
       }
       checkForConcreteClassWithAbstractMember(node);
-      checkForAllInvalidOverrideErrorCodes3(node);
+      checkForAllInvalidOverrideErrorCodes4(node);
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingFunction = previousFunction;
       _isInStaticMethod = false;
     }
   }
 
   Object visitMethodInvocation(MethodInvocation node) {
     Expression target = node.realTarget;
     SimpleIdentifier methodName = node.methodName;
@@ skipping 65 matching lines @@
     }
   }
 
   Object visitRethrowExpression(RethrowExpression node) {
     checkForRethrowOutsideCatch(node);
     return super.visitRethrowExpression(node);
   }
 
   Object visitReturnStatement(ReturnStatement node) {
     if (node.expression == null) {
-      _returnWithoutCount++;
+      _returnsWithout.add(node);
     } else {
-      _returnWithCount++;
+      _returnsWith.add(node);
     }
     checkForAllReturnStatementErrorCodes(node);
     return super.visitReturnStatement(node);
   }
 
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     checkForConstFormalParameter(node);
     checkForPrivateOptionalParameter(node);
     return super.visitSimpleFormalParameter(node);
   }
@@ skipping 194 matching lines @@
         }
       }
     }
     return foundError;
   }
 
   /**
    * This checks the passed executable element against override-error codes.
    *
    * @param executableElement a non-null [ExecutableElement] to evaluate
+   * @param overriddenExecutable the element that the executableElement is overriding
    * @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
    * @see StaticWarningCode#INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC
    * @see CompileTimeErrorCode#INVALID_OVERRIDE_REQUIRED
    * @see CompileTimeErrorCode#INVALID_OVERRIDE_POSITIONAL
    * @see CompileTimeErrorCode#INVALID_OVERRIDE_NAMED
    * @see StaticWarningCode#INVALID_GETTER_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE
    * @see StaticWarningCode#INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
    */
-  bool checkForAllInvalidOverrideErrorCodes(ExecutableElement executableElement, List<ParameterElement> parameters, List<ASTNode> parameterLocations, SimpleIdentifier errorNameTarget) {
-    String executableElementName = executableElement.name;
-    bool executableElementPrivate = Identifier.isPrivateName(executableElementName);
-    ExecutableElement overriddenExecutable = _inheritanceManager.lookupInheritance(_enclosingClass, executableElementName);
+  bool 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;
             }
@@ skipping 220 matching lines @@
                 overriddenExecutable.displayName]);
             foundError = true;
           }
         }
       }
     }
     return foundError;
   }
 
   /**
+   * This checks the passed executable element against override-error codes. This method computes
+   * the passed executableElement is overriding and calls
+   * [checkForAllInvalidOverrideErrorCodes]
+   * when the [InheritanceManager] returns a [MultiplyInheritedExecutableElement], this
+   * method loops through the array in the [MultiplyInheritedExecutableElement].
+   *
+   * @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 checkForAllInvalidOverrideErrorCodes2(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;
+        }
+      }
+      return false;
+    }
+    //
+    // Otherwise, just call checkForAllInvalidOverrideErrorCodes.
+    //
+    return checkForAllInvalidOverrideErrorCodes(executableElement, overriddenExecutable, parameters, parameterLocations, errorNameTarget);
+  }
+
+  /**
    * 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 checkForAllInvalidOverrideErrorCodes2(FieldDeclaration node) {
+  bool checkForAllInvalidOverrideErrorCodes3(FieldDeclaration node) {
     if (_enclosingClass == null || node.isStatic) {
       return false;
     }
     bool hasProblems = false;
     VariableDeclarationList fields = node.fields;
     for (VariableDeclaration field in fields.variables) {
       FieldElement element = field.element as FieldElement;
       if (element == null) {
         continue;
       }
       PropertyAccessorElement getter = element.getter;
       PropertyAccessorElement setter = element.setter;
       SimpleIdentifier fieldName = field.name;
       if (getter != null) {
-        hasProblems = javaBooleanOr(hasProblems, checkForAllInvalidOverrideErrorCodes(getter, ParameterElementImpl.EMPTY_ARRAY, ASTNode.EMPTY_ARRAY, fieldName));
+        hasProblems = javaBooleanOr(hasProblems, checkForAllInvalidOverrideErrorCodes2(getter, ParameterElementImpl.EMPTY_ARRAY, ASTNode.EMPTY_ARRAY, fieldName));
       }
       if (setter != null) {
-        hasProblems = javaBooleanOr(hasProblems, checkForAllInvalidOverrideErrorCodes(setter, setter.parameters, <ASTNode> [fieldName], fieldName));
+        hasProblems = javaBooleanOr(hasProblems, checkForAllInvalidOverrideErrorCodes2(setter, setter.parameters, <ASTNode> [fieldName], fieldName));
       }
     }
     return hasProblems;
   }
 
   /**
    * This checks the passed method 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 checkForAllInvalidOverrideErrorCodes3(MethodDeclaration node) {
+  bool checkForAllInvalidOverrideErrorCodes4(MethodDeclaration node) {
     if (_enclosingClass == null || node.isStatic || node.body is NativeFunctionBody) {
       return false;
     }
     ExecutableElement executableElement = node.element;
     if (executableElement == null) {
       return false;
     }
     SimpleIdentifier methodName = node.name;
     if (methodName.isSynthetic) {
       return false;
     }
     FormalParameterList formalParameterList = node.parameters;
     NodeList<FormalParameter> parameterList = formalParameterList != null ? formalParameterList.parameters : null;
     List<ASTNode> parameters = parameterList != null ? new List.from(parameterList) : null;
-    return checkForAllInvalidOverrideErrorCodes(executableElement, executableElement.parameters, parameters, methodName);
+    return checkForAllInvalidOverrideErrorCodes2(executableElement, executableElement.parameters, parameters, methodName);
   }
 
   /**
    * This verifies that all classes of the passed 'with' clause are valid.
    *
    * @param node the 'with' clause to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MIXIN_DECLARES_CONSTRUCTOR
    * @see CompileTimeErrorCode#MIXIN_INHERITS_FROM_NOT_OBJECT
    * @see CompileTimeErrorCode#MIXIN_REFERENCES_SUPER
@@ skipping 291 matching lines @@
       PropertyAccessorElement accessor = element as PropertyAccessorElement;
       element = accessor.variable;
     }
     if (element is VariableElement) {
       VariableElement variable = element as VariableElement;
       if (variable.isConst) {
         _errorReporter.reportError3(StaticWarningCode.ASSIGNMENT_TO_CONST, expression, []);
         return true;
       }
       if (variable.isFinal) {
-        _errorReporter.reportError3(StaticWarningCode.ASSIGNMENT_TO_FINAL, expression, []);
+        _errorReporter.reportError3(StaticWarningCode.ASSIGNMENT_TO_FINAL, expression, [variable.name]);
         return true;
       }
       return false;
     }
     if (element is MethodElement) {
       _errorReporter.reportError3(StaticWarningCode.ASSIGNMENT_TO_METHOD, expression, []);
       return true;
     }
     return false;
   }
@@ skipping 955 matching lines @@
    * This verifies that the passed constructor field initializer has compatible field and
    * initializer expression types.
    *
    * @param node the constructor field initializer to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE
    * @see StaticWarningCode#FIELD_INITIALIZER_NOT_ASSIGNABLE
    */
   bool checkForFieldInitializerNotAssignable(ConstructorFieldInitializer node) {
     // prepare field element
-    Element fieldNameElement = node.fieldName.staticElement;
-    if (fieldNameElement is! FieldElement) {
+    Element staticElement = node.fieldName.staticElement;
+    if (staticElement is! FieldElement) {
       return false;
     }
-    FieldElement fieldElement = fieldNameElement as FieldElement;
+    FieldElement fieldElement = staticElement as FieldElement;
     // prepare field type
     Type2 fieldType = fieldElement.type;
     // prepare expression type
     Expression expression = node.expression;
     if (expression == null) {
       return false;
     }
     // test the static type of the expression
     Type2 staticType = getStaticType(expression);
     if (staticType == null) {
@@ skipping 382 matching lines @@
     Type2 leftType = (leftElement == null) ? getStaticType(lhs) : leftElement.type;
     MethodElement invokedMethod = node.staticElement;
     if (invokedMethod == null) {
       return false;
     }
     Type2 rightType = invokedMethod.type.returnType;
     if (leftType == null || rightType == null) {
       return false;
     }
     if (!rightType.isAssignableTo(leftType)) {
-      _errorReporter.reportError3(StaticTypeWarningCode.INVALID_ASSIGNMENT, node.rightHandSide, [rightType.displayName, leftType.displayName]);
+      String leftName = leftType.displayName;
+      String rightName = rightType.displayName;
+      if (leftName == rightName) {
+        leftName = getExtendedDisplayName(leftType);
+        rightName = getExtendedDisplayName(rightType);
+      }
+      _errorReporter.reportError3(StaticTypeWarningCode.INVALID_ASSIGNMENT, node.rightHandSide, [rightName, leftName]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed left hand side and right hand side represent a valid assignment.
    *
    * @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 checkForInvalidAssignment2(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return false;
     }
     VariableElement leftElement = getVariableElement(lhs);
     Type2 leftType = (leftElement == null) ? getStaticType(lhs) : leftElement.type;
     Type2 staticRightType = getStaticType(rhs);
     bool isStaticAssignable = staticRightType.isAssignableTo(leftType);
     if (!isStaticAssignable) {
-      _errorReporter.reportError3(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [staticRightType.displayName, leftType.displayName]);
+      String leftName = leftType.displayName;
+      String rightName = staticRightType.displayName;
+      if (leftName == rightName) {
+        leftName = getExtendedDisplayName(leftType);
+        rightName = getExtendedDisplayName(staticRightType);
+      }
+      _errorReporter.reportError3(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;
   }
 
   /**
+   * Check the given initializer to ensure that the field being initialized is a valid field.
+   *
+   * @param node the field initializer being checked
+   */
+  void checkForInvalidField(ConstructorFieldInitializer node) {
+    SimpleIdentifier fieldName = node.fieldName;
+    Element staticElement = fieldName.staticElement;
+    if (staticElement is FieldElement) {
+      FieldElement fieldElement = staticElement;
+      if (fieldElement.isSynthetic) {
+        _errorReporter.reportError3(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
+      } else if (fieldElement.isStatic) {
+        _errorReporter.reportError3(CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [fieldName]);
+      }
+    } else {
+      _errorReporter.reportError3(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
+      return;
+    }
+  }
+
+  /**
    * This verifies that the usage of the passed 'this' is valid.
    *
    * @param node the 'this' expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#INVALID_REFERENCE_TO_THIS
    */
   bool checkForInvalidReferenceToThis(ThisExpression node) {
     if (!isThisInValidContext(node)) {
       _errorReporter.reportError3(CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS, node, []);
       return true;
@@ skipping 213 matching lines @@
 
   /**
    * This verifies that the given function body does not contain return statements that both have
    * and do not have return values.
    *
    * @param node the function body being tested
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#MIXED_RETURN_TYPES
    */
   bool checkForMixedReturns(BlockFunctionBody node) {
-    if (_returnWithCount > 0 && _returnWithoutCount > 0) {
-      _errorReporter.reportError3(StaticWarningCode.MIXED_RETURN_TYPES, node, []);
+    int withCount = _returnsWith.length;
+    int withoutCount = _returnsWithout.length;
+    if (withCount > 0 && withoutCount > 0) {
+      for (int i = 0; i < withCount; i++) {
+        _errorReporter.reportError6(StaticWarningCode.MIXED_RETURN_TYPES, _returnsWith[i].keyword, []);
+      }
+      for (int i = 0; i < withoutCount; i++) {
+        _errorReporter.reportError6(StaticWarningCode.MIXED_RETURN_TYPES, _returnsWithout[i].keyword, []);
+      }
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin does not have an explicitly declared constructor.
    *
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
@@ skipping 192 matching lines @@
     // 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);
       if (memberName == null) {
         break;
       }
-      // If the element is defined in Object, skip it.
-      if ((executableElt.enclosingElement as ClassElement).type.isObject) {
+      // If the element is not synthetic and can be determined to be defined in Object, skip it.
+      if (executableElt.enclosingElement != null && (executableElt.enclosingElement as ClassElement).type.isObject) {
         continue;
       }
       // Reference the type of the enclosing class
       InterfaceType enclosingType = _enclosingClass.type;
       // Check to see if some element is in local enclosing class that matches the name of the
       // required member.
       if (isMemberInClassOrMixin(executableElt, _enclosingClass)) {
         // We do not have to verify that this implementation of the found method matches the
         // required function type: the set of StaticWarningCode.INVALID_METHOD_OVERRIDE_* warnings
         // break out the different specific situations.
@@ skipping 23 matching lines @@
       missingOverrides.add(executableElt);
     }
     // Now that we have the set of missing overrides, generate a warning on this class
     int missingOverridesSize = missingOverrides.length;
     if (missingOverridesSize == 0) {
       return false;
     }
     List<ExecutableElement> missingOverridesArray = new List.from(missingOverrides);
     List<String> stringMembersArrayListSet = new List<String>();
     for (int i = 0; i < missingOverridesArray.length; i++) {
-      String newStrMember = "${missingOverridesArray[i].enclosingElement.displayName}.${missingOverridesArray[i].displayName}";
+      String newStrMember;
+      if (missingOverridesArray[i].enclosingElement != null) {
+        newStrMember = "${missingOverridesArray[i].enclosingElement.displayName}.${missingOverridesArray[i].displayName}";
+      } else {
+        newStrMember = missingOverridesArray[i].displayName;
+      }
       if (!stringMembersArrayListSet.contains(newStrMember)) {
         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]]);
     } else if (stringMembersArray.length == 2) {
       analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO, node.name, [stringMembersArray[0], stringMembersArray[1]]);
@@ skipping 765 matching lines @@
     if ((element is MethodElement && !element.isStatic) || (element is PropertyAccessorElement && !element.isStatic)) {
       return false;
     }
     if (identical(enclosingElement, _enclosingClass)) {
       return false;
     }
     _errorReporter.reportError3(StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER, name, [name.name]);
     return true;
   }
 
+  void checkForValidField(FieldFormalParameter node) {
+    ParameterElement element = node.element;
+    if (element is FieldFormalParameterElement) {
+      FieldElement fieldElement = element.field;
+      if (fieldElement == null || fieldElement.isSynthetic) {
+        _errorReporter.reportError3(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [node.identifier.name]);
+      } else {
+        ParameterElement parameterElement = node.element;
+        if (parameterElement is FieldFormalParameterElementImpl) {
+          FieldFormalParameterElementImpl fieldFormal = parameterElement;
+          Type2 declaredType = fieldFormal.type;
+          Type2 fieldType = fieldElement.type;
+          if (fieldElement.isSynthetic) {
+            _errorReporter.reportError3(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [node.identifier.name]);
+          } else if (fieldElement.isStatic) {
+            _errorReporter.reportError3(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [node.identifier.name]);
+          } else if (declaredType != null && fieldType != null && !declaredType.isAssignableTo(fieldType)) {
+            _errorReporter.reportError3(StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE, node, [declaredType.displayName, fieldType.displayName]);
+          }
+        } else {
+          if (fieldElement.isSynthetic) {
+            _errorReporter.reportError3(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [node.identifier.name]);
+          } else if (fieldElement.isStatic) {
+            _errorReporter.reportError3(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [node.identifier.name]);
+          }
+        }
+      }
+    }
+  }
+
   /**
    * This verifies the passed operator-method declaration, has correct number of parameters.
    *
    * This method assumes that the method declaration was tested to be an operator declaration before
    * being called.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR
    */
@@ skipping 107 matching lines @@
       if (interfaceNode.type == superType) {
         hasProblem = true;
         _errorReporter.reportError3(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(Type2 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.
    */
   Type2 getGetterType(PropertyAccessorElement propertyAccessorElement) {
     FunctionType functionType = propertyAccessorElement.type;
     if (functionType != null) {
       return functionType.returnType;
     } else {
@@ skipping 252 matching lines @@
     if (parent is CommentReference) {
       CommentReference commentReference = parent;
       if (commentReference.newKeyword != null) {
         return true;
       }
     }
     return false;
   }
 
   bool isUserDefinedObject(EvaluationResultImpl result) => result == null || (result is ValidResult && result.isUserDefinedObject);
-
-  /**
-   * Return `true` iff the passed [ClassElement] has a concrete implementation of the
-   * passed accessor name in the superclass chain.
-   */
-  bool memberHasConcreteAccessorImplementationInSuperclassChain(ClassElement classElement, String accessorName, List<ClassElement> superclassChain) {
-    if (superclassChain.contains(classElement)) {
-      return false;
-    } else {
-      superclassChain.add(classElement);
-    }
-    for (PropertyAccessorElement accessor in classElement.accessors) {
-      if (accessor.name == accessorName) {
-        if (!accessor.isAbstract) {
-          return true;
-        }
-      }
-    }
-    for (InterfaceType mixinType in classElement.mixins) {
-      if (mixinType != null) {
-        ClassElement mixinElement = mixinType.element;
-        if (mixinElement != null) {
-          for (PropertyAccessorElement accessor in mixinElement.accessors) {
-            if (accessor.name == accessorName) {
-              if (!accessor.isAbstract) {
-                return true;
-              }
-            }
-          }
-        }
-      }
-    }
-    InterfaceType superType = classElement.supertype;
-    if (superType != null) {
-      ClassElement superClassElt = superType.element;
-      if (superClassElt != null) {
-        return memberHasConcreteAccessorImplementationInSuperclassChain(superClassElt, accessorName, superclassChain);
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Return `true` iff the passed [ClassElement] has a concrete implementation of the
-   * passed method name in the superclass chain.
-   */
-  bool memberHasConcreteMethodImplementationInSuperclassChain(ClassElement classElement, String methodName, List<ClassElement> superclassChain) {
-    if (superclassChain.contains(classElement)) {
-      return false;
-    } else {
-      superclassChain.add(classElement);
-    }
-    for (MethodElement method in classElement.methods) {
-      if (method.name == methodName) {
-        if (!method.isAbstract) {
-          return true;
-        }
-      }
-    }
-    for (InterfaceType mixinType in classElement.mixins) {
-      if (mixinType != null) {
-        ClassElement mixinElement = mixinType.element;
-        if (mixinElement != null) {
-          for (MethodElement method in mixinElement.methods) {
-            if (method.name == methodName) {
-              if (!method.isAbstract) {
-                return true;
-              }
-            }
-          }
-        }
-      }
-    }
-    InterfaceType superType = classElement.supertype;
-    if (superType != null) {
-      ClassElement superClassElt = superType.element;
-      if (superClassElt != null) {
-        return memberHasConcreteMethodImplementationInSuperclassChain(superClassElt, methodName, superclassChain);
-      }
-    }
-    return false;
-  }
 }
 
 /**
  * This enum holds one of four states of a field initialization state through a constructor
  * signature, not initialized, initialized in the field declaration, initialized in the field
  * formal, and finally, initialized in the initializers list.
  */
 class INIT_STATE extends Enum<INIT_STATE> {
   static final INIT_STATE NOT_INIT = new INIT_STATE('NOT_INIT', 0);
 
@@ skipping 135 matching lines @@
    * @param correction the template used to create the correction to be displayed for the error
    */
   ResolverErrorCode.con2(String name, int ordinal, this.type, this.message, String correction) : super(name, ordinal) {
     this.correction9 = correction;
   }
 
   String get correction => correction9;
 
   ErrorSeverity get errorSeverity => type.severity;
 }