Stop running pub get at gclient sync time and fix build bugs

mojo/public/dart/third_party/analyzer/lib/src/generated/resolver.dart

+// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library engine.resolver;
+
+import 'dart:collection';
+
+import 'ast.dart';
+import 'constant.dart';
+import 'element.dart';
+import 'element_resolver.dart';
+import 'engine.dart';
+import 'error.dart';
+import 'error_verifier.dart';
+import 'html.dart' as ht;
+import 'java_core.dart';
+import 'java_engine.dart';
+import 'scanner.dart' as sc;
+import 'sdk.dart' show DartSdk, SdkLibrary;
+import 'source.dart';
+import 'static_type_analyzer.dart';
+import 'utilities_dart.dart';
+
+/**
+ * Callback signature used by ImplicitConstructorBuilder to register
+ * computations to be performed, and their dependencies.  A call to this
+ * callback indicates that [computation] may be used to compute implicit
+ * constructors for [classElement], but that the computation may not be invoked
+ * until after implicit constructors have been built for [superclassElement].
+ */
+typedef void ImplicitConstructorBuilderCallback(ClassElement classElement,
+    ClassElement superclassElement, void computation());
+
+typedef LibraryResolver LibraryResolverFactory(AnalysisContext context);
+
+typedef ResolverVisitor ResolverVisitorFactory(
+    Library library, Source source, TypeProvider typeProvider);
+
+typedef StaticTypeAnalyzer StaticTypeAnalyzerFactory(ResolverVisitor visitor);
+
+typedef TypeResolverVisitor TypeResolverVisitorFactory(
+    Library library, Source source, TypeProvider typeProvider);
+
+typedef void VoidFunction();
+
+/**
+ * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
+ * violations of Dart best practices.
+ */
+class BestPracticesVerifier extends RecursiveAstVisitor<Object> {
+//  static String _HASHCODE_GETTER_NAME = "hashCode";
+
+  static String _NULL_TYPE_NAME = "Null";
+
+  static String _TO_INT_METHOD_NAME = "toInt";
+
+  /**
+   * The class containing the AST nodes being visited, or `null` if we are not in the scope of
+   * a class.
+   */
+  ClassElement _enclosingClass;
+
+  /**
+   * The error reporter by which errors will be reported.
+   */
+  final ErrorReporter _errorReporter;
+
+  /**
+   * The type Future<Null>, which is needed for determining whether it is safe
+   * to have a bare "return;" in an async method.
+   */
+  final InterfaceType _futureNullType;
+
+  /**
+   * Create a new instance of the [BestPracticesVerifier].
+   *
+   * @param errorReporter the error reporter
+   */
+  BestPracticesVerifier(this._errorReporter, TypeProvider typeProvider)
+      : _futureNullType = typeProvider.futureNullType;
+
+  @override
+  Object visitArgumentList(ArgumentList node) {
+    _checkForArgumentTypesNotAssignableInList(node);
+    return super.visitArgumentList(node);
+  }
+
+  @override
+  Object visitAsExpression(AsExpression node) {
+    _checkForUnnecessaryCast(node);
+    return super.visitAsExpression(node);
+  }
+
+  @override
+  Object visitAssignmentExpression(AssignmentExpression node) {
+    sc.TokenType operatorType = node.operator.type;
+    if (operatorType == sc.TokenType.EQ) {
+      _checkForUseOfVoidResult(node.rightHandSide);
+      _checkForInvalidAssignment(node.leftHandSide, node.rightHandSide);
+    } else {
+      _checkForDeprecatedMemberUse(node.bestElement, node);
+    }
+    return super.visitAssignmentExpression(node);
+  }
+
+  @override
+  Object visitBinaryExpression(BinaryExpression node) {
+    _checkForDivisionOptimizationHint(node);
+    _checkForDeprecatedMemberUse(node.bestElement, node);
+    return super.visitBinaryExpression(node);
+  }
+
+  @override
+  Object visitClassDeclaration(ClassDeclaration node) {
+    ClassElement outerClass = _enclosingClass;
+    try {
+      _enclosingClass = node.element;
+      // Commented out until we decide that we want this hint in the analyzer
+      //    checkForOverrideEqualsButNotHashCode(node);
+      return super.visitClassDeclaration(node);
+    } finally {
+      _enclosingClass = outerClass;
+    }
+  }
+
+  @override
+  Object visitExportDirective(ExportDirective node) {
+    _checkForDeprecatedMemberUse(node.uriElement, node);
+    return super.visitExportDirective(node);
+  }
+
+  @override
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    _checkForMissingReturn(node.returnType, node.functionExpression.body);
+    return super.visitFunctionDeclaration(node);
+  }
+
+  @override
+  Object visitImportDirective(ImportDirective node) {
+    _checkForDeprecatedMemberUse(node.uriElement, node);
+    ImportElement importElement = node.element;
+    if (importElement != null) {
+      if (importElement.isDeferred) {
+        _checkForLoadLibraryFunction(node, importElement);
+      }
+    }
+    return super.visitImportDirective(node);
+  }
+
+  @override
+  Object visitIndexExpression(IndexExpression node) {
+    _checkForDeprecatedMemberUse(node.bestElement, node);
+    return super.visitIndexExpression(node);
+  }
+
+  @override
+  Object visitInstanceCreationExpression(InstanceCreationExpression node) {
+    _checkForDeprecatedMemberUse(node.staticElement, node);
+    return super.visitInstanceCreationExpression(node);
+  }
+
+  @override
+  Object visitIsExpression(IsExpression node) {
+    _checkAllTypeChecks(node);
+    return super.visitIsExpression(node);
+  }
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    // This was determined to not be a good hint, see: dartbug.com/16029
+    //checkForOverridingPrivateMember(node);
+    _checkForMissingReturn(node.returnType, node.body);
+    return super.visitMethodDeclaration(node);
+  }
+
+  @override
+  Object visitPostfixExpression(PostfixExpression node) {
+    _checkForDeprecatedMemberUse(node.bestElement, node);
+    return super.visitPostfixExpression(node);
+  }
+
+  @override
+  Object visitPrefixExpression(PrefixExpression node) {
+    _checkForDeprecatedMemberUse(node.bestElement, node);
+    return super.visitPrefixExpression(node);
+  }
+
+  @override
+  Object visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
+    _checkForDeprecatedMemberUse(node.staticElement, node);
+    return super.visitRedirectingConstructorInvocation(node);
+  }
+
+  @override
+  Object visitSimpleIdentifier(SimpleIdentifier node) {
+    _checkForDeprecatedMemberUseAtIdentifier(node);
+    return super.visitSimpleIdentifier(node);
+  }
+
+  @override
+  Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
+    _checkForDeprecatedMemberUse(node.staticElement, node);
+    return super.visitSuperConstructorInvocation(node);
+  }
+
+  @override
+  Object visitVariableDeclaration(VariableDeclaration node) {
+    _checkForUseOfVoidResult(node.initializer);
+    _checkForInvalidAssignment(node.name, node.initializer);
+    return super.visitVariableDeclaration(node);
+  }
+
+  /**
+   * Check for the passed is expression for the unnecessary type check hint codes as well as null
+   * checks expressed using an is expression.
+   *
+   * @param node the is expression to check
+   * @return `true` if and only if a hint code is generated on the passed node
+   * See [HintCode.TYPE_CHECK_IS_NOT_NULL], [HintCode.TYPE_CHECK_IS_NULL],
+   * [HintCode.UNNECESSARY_TYPE_CHECK_TRUE], and
+   * [HintCode.UNNECESSARY_TYPE_CHECK_FALSE].
+   */
+  bool _checkAllTypeChecks(IsExpression node) {
+    Expression expression = node.expression;
+    TypeName typeName = node.type;
+    DartType lhsType = expression.staticType;
+    DartType rhsType = typeName.type;
+    if (lhsType == null || rhsType == null) {
+      return false;
+    }
+    String rhsNameStr = typeName.name.name;
+    // if x is dynamic
+    if (rhsType.isDynamic && rhsNameStr == sc.Keyword.DYNAMIC.syntax) {
+      if (node.notOperator == null) {
+        // the is case
+        _errorReporter.reportErrorForNode(
+            HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
+      } else {
+        // the is not case
+        _errorReporter.reportErrorForNode(
+            HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
+      }
+      return true;
+    }
+    Element rhsElement = rhsType.element;
+    LibraryElement libraryElement =
+        rhsElement != null ? rhsElement.library : null;
+    if (libraryElement != null && libraryElement.isDartCore) {
+      // if x is Object or null is Null
+      if (rhsType.isObject ||
+          (expression is NullLiteral && rhsNameStr == _NULL_TYPE_NAME)) {
+        if (node.notOperator == null) {
+          // the is case
+          _errorReporter.reportErrorForNode(
+              HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
+        } else {
+          // the is not case
+          _errorReporter.reportErrorForNode(
+              HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
+        }
+        return true;
+      } else if (rhsNameStr == _NULL_TYPE_NAME) {
+        if (node.notOperator == null) {
+          // the is case
+          _errorReporter.reportErrorForNode(HintCode.TYPE_CHECK_IS_NULL, node);
+        } else {
+          // the is not case
+          _errorReporter.reportErrorForNode(
+              HintCode.TYPE_CHECK_IS_NOT_NULL, node);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * This verifies that the passed expression can be assigned to its corresponding parameters.
+   *
+   * This method corresponds to ErrorVerifier.checkForArgumentTypeNotAssignable.
+   *
+   * TODO (jwren) In the ErrorVerifier there are other warnings that we could have a corresponding
+   * hint for: see other callers of ErrorVerifier.checkForArgumentTypeNotAssignable(..).
+   *
+   * @param expression the expression to evaluate
+   * @param expectedStaticType the expected static type of the parameter
+   * @param actualStaticType the actual static type of the argument
+   * @param expectedPropagatedType the expected propagated type of the parameter, may be
+   *          `null`
+   * @param actualPropagatedType the expected propagated type of the parameter, may be `null`
+   * @return `true` if and only if an hint code is generated on the passed node
+   * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
+   */
+  bool _checkForArgumentTypeNotAssignable(
+      Expression expression,
+      DartType expectedStaticType,
+      DartType actualStaticType,
+      DartType expectedPropagatedType,
+      DartType actualPropagatedType,
+      ErrorCode hintCode) {
+    //
+    // Warning case: test static type information
+    //
+    if (actualStaticType != null && expectedStaticType != null) {
+      if (!actualStaticType.isAssignableTo(expectedStaticType)) {
+        // A warning was created in the ErrorVerifier, return false, don't
+        // create a hint when a warning has already been created.
+        return false;
+      }
+    }
+    //
+    // Hint case: test propagated type information
+    //
+    // Compute the best types to use.
+    DartType expectedBestType = expectedPropagatedType != null
+        ? expectedPropagatedType
+        : expectedStaticType;
+    DartType actualBestType =
+        actualPropagatedType != null ? actualPropagatedType : actualStaticType;
+    if (actualBestType != null && expectedBestType != null) {
+      if (!actualBestType.isAssignableTo(expectedBestType)) {
+        _errorReporter.reportTypeErrorForNode(
+            hintCode, expression, [actualBestType, expectedBestType]);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * This verifies that the passed argument can be assigned to its corresponding parameter.
+   *
+   * This method corresponds to ErrorCode.checkForArgumentTypeNotAssignableForArgument.
+   *
+   * @param argument the argument to evaluate
+   * @return `true` if and only if an hint code is generated on the passed node
+   * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
+   */
+  bool _checkForArgumentTypeNotAssignableForArgument(Expression argument) {
+    if (argument == null) {
+      return false;
+    }
+    ParameterElement staticParameterElement = argument.staticParameterElement;
+    DartType staticParameterType =
+        staticParameterElement == null ? null : staticParameterElement.type;
+    ParameterElement propagatedParameterElement =
+        argument.propagatedParameterElement;
+    DartType propagatedParameterType = propagatedParameterElement == null
+        ? null
+        : propagatedParameterElement.type;
+    return _checkForArgumentTypeNotAssignableWithExpectedTypes(
+        argument,
+        staticParameterType,
+        propagatedParameterType,
+        HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
+  }
+
+  /**
+   * This verifies that the passed expression can be assigned to its corresponding parameters.
+   *
+   * This method corresponds to ErrorCode.checkForArgumentTypeNotAssignableWithExpectedTypes.
+   *
+   * @param expression the expression to evaluate
+   * @param expectedStaticType the expected static type
+   * @param expectedPropagatedType the expected propagated type, may be `null`
+   * @return `true` if and only if an hint code is generated on the passed node
+   * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
+   */
+  bool _checkForArgumentTypeNotAssignableWithExpectedTypes(
+          Expression expression,
+          DartType expectedStaticType,
+          DartType expectedPropagatedType,
+          ErrorCode errorCode) =>
+      _checkForArgumentTypeNotAssignable(
+          expression,
+          expectedStaticType,
+          expression.staticType,
+          expectedPropagatedType,
+          expression.propagatedType,
+          errorCode);
+
+  /**
+   * This verifies that the passed arguments can be assigned to their corresponding parameters.
+   *
+   * This method corresponds to ErrorCode.checkForArgumentTypesNotAssignableInList.
+   *
+   * @param node the arguments to evaluate
+   * @return `true` if and only if an hint code is generated on the passed node
+   * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
+   */
+  bool _checkForArgumentTypesNotAssignableInList(ArgumentList argumentList) {
+    if (argumentList == null) {
+      return false;
+    }
+    bool problemReported = false;
+    for (Expression argument in argumentList.arguments) {
+      if (_checkForArgumentTypeNotAssignableForArgument(argument)) {
+        problemReported = true;
+      }
+    }
+    return problemReported;
+  }
+
+  /**
+   * Given some [Element], look at the associated metadata and report the use of the member if
+   * it is declared as deprecated.
+   *
+   * @param element some element to check for deprecated use of
+   * @param node the node use for the location of the error
+   * @return `true` if and only if a hint code is generated on the passed node
+   * See [HintCode.DEPRECATED_MEMBER_USE].
+   */
+  bool _checkForDeprecatedMemberUse(Element element, AstNode node) {
+    if (element != null && element.isDeprecated) {
+      String displayName = element.displayName;
+      if (element is ConstructorElement) {
+        // TODO(jwren) We should modify ConstructorElement.getDisplayName(),
+        // or have the logic centralized elsewhere, instead of doing this logic
+        // here.
+        ConstructorElement constructorElement = element;
+        displayName = constructorElement.enclosingElement.displayName;
+        if (!constructorElement.displayName.isEmpty) {
+          displayName = "$displayName.${constructorElement.displayName}";
+        }
+      }
+      _errorReporter.reportErrorForNode(
+          HintCode.DEPRECATED_MEMBER_USE, node, [displayName]);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * For [SimpleIdentifier]s, only call [checkForDeprecatedMemberUse]
+   * if the node is not in a declaration context.
+   *
+   * Also, if the identifier is a constructor name in a constructor invocation, then calls to the
+   * deprecated constructor will be caught by
+   * [visitInstanceCreationExpression] and
+   * [visitSuperConstructorInvocation], and can be ignored by
+   * this visit method.
+   *
+   * @param identifier some simple identifier to check for deprecated use of
+   * @return `true` if and only if a hint code is generated on the passed node
+   * See [HintCode.DEPRECATED_MEMBER_USE].
+   */
+  bool _checkForDeprecatedMemberUseAtIdentifier(SimpleIdentifier identifier) {
+    if (identifier.inDeclarationContext()) {
+      return false;
+    }
+    AstNode parent = identifier.parent;
+    if ((parent is ConstructorName && identical(identifier, parent.name)) ||
+        (parent is SuperConstructorInvocation &&
+            identical(identifier, parent.constructorName)) ||
+        parent is HideCombinator) {
+      return false;
+    }
+    return _checkForDeprecatedMemberUse(identifier.bestElement, identifier);
+  }
+
+  /**
+   * Check for the passed binary expression for the [HintCode.DIVISION_OPTIMIZATION].
+   *
+   * @param node the binary expression to check
+   * @return `true` if and only if a hint code is generated on the passed node
+   * See [HintCode.DIVISION_OPTIMIZATION].
+   */
+  bool _checkForDivisionOptimizationHint(BinaryExpression node) {
+    // Return if the operator is not '/'
+    if (node.operator.type != sc.TokenType.SLASH) {
+      return false;
+    }
+    // Return if the '/' operator is not defined in core, or if we don't know
+    // its static or propagated type
+    MethodElement methodElement = node.bestElement;
+    if (methodElement == null) {
+      return false;
+    }
+    LibraryElement libraryElement = methodElement.library;
+    if (libraryElement != null && !libraryElement.isDartCore) {
+      return false;
+    }
+    // Report error if the (x/y) has toInt() invoked on it
+    if (node.parent is ParenthesizedExpression) {
+      ParenthesizedExpression parenthesizedExpression =
+          _wrapParenthesizedExpression(node.parent as ParenthesizedExpression);
+      if (parenthesizedExpression.parent is MethodInvocation) {
+        MethodInvocation methodInvocation =
+            parenthesizedExpression.parent as MethodInvocation;
+        if (_TO_INT_METHOD_NAME == methodInvocation.methodName.name &&
+            methodInvocation.argumentList.arguments.isEmpty) {
+          _errorReporter.reportErrorForNode(
+              HintCode.DIVISION_OPTIMIZATION, methodInvocation);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * This verifies that the passed left hand side and right hand side represent a valid assignment.
+   *
+   * This method corresponds to ErrorVerifier.checkForInvalidAssignment.
+   *
+   * @param lhs the left hand side expression
+   * @param rhs the right hand side expression
+   * @return `true` if and only if an error code is generated on the passed node
+   * See [HintCode.INVALID_ASSIGNMENT].
+   */
+  bool _checkForInvalidAssignment(Expression lhs, Expression rhs) {
+    if (lhs == null || rhs == null) {
+      return false;
+    }
+    VariableElement leftVariableElement = ErrorVerifier.getVariableElement(lhs);
+    DartType leftType = (leftVariableElement == null)
+        ? ErrorVerifier.getStaticType(lhs)
+        : leftVariableElement.type;
+    DartType staticRightType = ErrorVerifier.getStaticType(rhs);
+    if (!staticRightType.isAssignableTo(leftType)) {
+      // The warning was generated on this rhs
+      return false;
+    }
+    // Test for, and then generate the hint
+    DartType bestRightType = rhs.bestType;
+    if (leftType != null && bestRightType != null) {
+      if (!bestRightType.isAssignableTo(leftType)) {
+        _errorReporter.reportTypeErrorForNode(
+            HintCode.INVALID_ASSIGNMENT, rhs, [bestRightType, leftType]);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Check that the imported library does not define a loadLibrary function. The import has already
+   * been determined to be deferred when this is called.
+   *
+   * @param node the import directive to evaluate
+   * @param importElement the [ImportElement] retrieved from the node
+   * @return `true` if and only if an error code is generated on the passed node
+   * See [CompileTimeErrorCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION].
+   */
+  bool _checkForLoadLibraryFunction(
+      ImportDirective node, ImportElement importElement) {
+    LibraryElement importedLibrary = importElement.importedLibrary;
+    if (importedLibrary == null) {
+      return false;
+    }
+    if (importedLibrary.hasLoadLibraryFunction) {
+      _errorReporter.reportErrorForNode(
+          HintCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION,
+          node,
+          [importedLibrary.name]);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Generate a hint for functions or methods that have a return type, but do not have a return
+   * statement on all branches. At the end of blocks with no return, Dart implicitly returns
+   * `null`, avoiding these implicit returns is considered a best practice.
+   *
+   * Note: for async functions/methods, this hint only applies when the
+   * function has a return type that Future<Null> is not assignable to.
+   *
+   * @param node the binary expression to check
+   * @param body the function body
+   * @return `true` if and only if a hint code is generated on the passed node
+   * See [HintCode.MISSING_RETURN].
+   */
+  bool _checkForMissingReturn(TypeName returnType, FunctionBody body) {
+    // Check that the method or function has a return type, and a function body
+    if (returnType == null || body == null) {
+      return false;
+    }
+    // Check that the body is a BlockFunctionBody
+    if (body is! BlockFunctionBody) {
+      return false;
+    }
+    // Generators are never required to have a return statement.
+    if (body.isGenerator) {
+      return false;
+    }
+    // Check that the type is resolvable, and is not "void"
+    DartType returnTypeType = returnType.type;
+    if (returnTypeType == null || returnTypeType.isVoid) {
+      return false;
+    }
+    // For async, give no hint if Future<Null> is assignable to the return
+    // type.
+    if (body.isAsynchronous && _futureNullType.isAssignableTo(returnTypeType)) {
+      return false;
+    }
+    // Check the block for a return statement, if not, create the hint
+    BlockFunctionBody blockFunctionBody = body as BlockFunctionBody;
+    if (!ExitDetector.exits(blockFunctionBody)) {
+      _errorReporter.reportErrorForNode(
+          HintCode.MISSING_RETURN, returnType, [returnTypeType.displayName]);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Check for the passed class declaration for the
+   * [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE] hint code.
+   *
+   * @param node the class declaration to check
+   * @return `true` if and only if a hint code is generated on the passed node
+   * See [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE].
+   */
+//  bool _checkForOverrideEqualsButNotHashCode(ClassDeclaration node) {
+//    ClassElement classElement = node.element;
+//    if (classElement == null) {
+//      return false;
+//    }
+//    MethodElement equalsOperatorMethodElement =
+//        classElement.getMethod(sc.TokenType.EQ_EQ.lexeme);
+//    if (equalsOperatorMethodElement != null) {
+//      PropertyAccessorElement hashCodeElement =
+//          classElement.getGetter(_HASHCODE_GETTER_NAME);
+//      if (hashCodeElement == null) {
+//        _errorReporter.reportErrorForNode(
+//            HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE,
+//            node.name,
+//            [classElement.displayName]);
+//        return true;
+//      }
+//    }
+//    return false;
+//  }
+
+  /**
+   * Check for the passed as expression for the [HintCode.UNNECESSARY_CAST] hint code.
+   *
+   * @param node the as expression to check
+   * @return `true` if and only if a hint code is generated on the passed node
+   * See [HintCode.UNNECESSARY_CAST].
+   */
+  bool _checkForUnnecessaryCast(AsExpression node) {
+    // TODO(jwren) After dartbug.com/13732, revisit this, we should be able to
+    // remove the (x is! TypeParameterType) checks.
+    AstNode parent = node.parent;
+    if (parent is ConditionalExpression &&
+        (node == parent.thenExpression || node == parent.elseExpression)) {
+      Expression thenExpression = parent.thenExpression;
+      DartType thenType;
+      if (thenExpression is AsExpression) {
+        thenType = thenExpression.expression.staticType;
+      } else {
+        thenType = thenExpression.staticType;
+      }
+      Expression elseExpression = parent.elseExpression;
+      DartType elseType;
+      if (elseExpression is AsExpression) {
+        elseType = elseExpression.expression.staticType;
+      } else {
+        elseType = elseExpression.staticType;
+      }
+      if (thenType != null &&
+          elseType != null &&
+          !thenType.isDynamic &&
+          !elseType.isDynamic &&
+          !thenType.isMoreSpecificThan(elseType) &&
+          !elseType.isMoreSpecificThan(thenType)) {
+        return false;
+      }
+    }
+    DartType lhsType = node.expression.staticType;
+    DartType rhsType = node.type.type;
+    if (lhsType != null &&
+        rhsType != null &&
+        !lhsType.isDynamic &&
+        !rhsType.isDynamic &&
+        lhsType.isMoreSpecificThan(rhsType)) {
+      _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_CAST, node);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Check for situations where the result of a method or function is used, when it returns 'void'.
+   *
+   * TODO(jwren) Many other situations of use could be covered. We currently cover the cases var x =
+   * m() and x = m(), but we could also cover cases such as m().x, m()[k], a + m(), f(m()), return
+   * m().
+   *
+   * @param node expression on the RHS of some assignment
+   * @return `true` if and only if a hint code is generated on the passed node
+   * See [HintCode.USE_OF_VOID_RESULT].
+   */
+  bool _checkForUseOfVoidResult(Expression expression) {
+    if (expression == null || expression is! MethodInvocation) {
+      return false;
+    }
+    MethodInvocation methodInvocation = expression as MethodInvocation;
+    if (identical(methodInvocation.staticType, VoidTypeImpl.instance)) {
+      SimpleIdentifier methodName = methodInvocation.methodName;
+      _errorReporter.reportErrorForNode(
+          HintCode.USE_OF_VOID_RESULT, methodName, [methodName.name]);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Given a parenthesized expression, this returns the parent (or recursively grand-parent) of the
+   * expression that is a parenthesized expression, but whose parent is not a parenthesized
+   * expression.
+   *
+   * For example given the code `(((e)))`: `(e) -> (((e)))`.
+   *
+   * @param parenthesizedExpression some expression whose parent is a parenthesized expression
+   * @return the first parent or grand-parent that is a parenthesized expression, that does not have
+   *         a parenthesized expression parent
+   */
+  static ParenthesizedExpression _wrapParenthesizedExpression(
+      ParenthesizedExpression parenthesizedExpression) {
+    if (parenthesizedExpression.parent is ParenthesizedExpression) {
+      return _wrapParenthesizedExpression(
+          parenthesizedExpression.parent as ParenthesizedExpression);
+    }
+    return parenthesizedExpression;
+  }
+}
+
+/**
+ * Instances of the class `ClassScope` implement the scope defined by a class.
+ */
+class ClassScope extends EnclosedScope {
+  /**
+   * Initialize a newly created scope enclosed within another scope.
+   *
+   * @param enclosingScope the scope in which this scope is lexically enclosed
+   * @param typeElement the element representing the type represented by this scope
+   */
+  ClassScope(Scope enclosingScope, ClassElement typeElement)
+      : super(enclosingScope) {
+    if (typeElement == null) {
+      throw new IllegalArgumentException("class element cannot be null");
+    }
+    _defineMembers(typeElement);
+  }
+
+  @override
+  AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
+    if (existing is PropertyAccessorElement && duplicate is MethodElement) {
+      if (existing.nameOffset < duplicate.nameOffset) {
+        return new AnalysisError(
+            duplicate.source,
+            duplicate.nameOffset,
+            duplicate.displayName.length,
+            CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME,
+            [existing.displayName]);
+      } else {
+        return new AnalysisError(
+            existing.source,
+            existing.nameOffset,
+            existing.displayName.length,
+            CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME,
+            [existing.displayName]);
+      }
+    }
+    return super.getErrorForDuplicate(existing, duplicate);
+  }
+
+  /**
+   * Define the instance members defined by the class.
+   *
+   * @param typeElement the element representing the type represented by this scope
+   */
+  void _defineMembers(ClassElement typeElement) {
+    for (PropertyAccessorElement accessor in typeElement.accessors) {
+      define(accessor);
+    }
+    for (MethodElement method in typeElement.methods) {
+      define(method);
+    }
+  }
+}
+
+/**
+ * A `CompilationUnitBuilder` builds an element model for a single compilation
+ * unit.
+ */
+class CompilationUnitBuilder {
+  /**
+   * Build the compilation unit element for the given [source] based on the
+   * compilation [unit] associated with the source. Throw an AnalysisException
+   * if the element could not be built.  [librarySource] is the source for the
+   * containing library.
+   */
+  CompilationUnitElementImpl buildCompilationUnit(
+      Source source, CompilationUnit unit, Source librarySource) {
+    return PerformanceStatistics.resolve.makeCurrentWhile(() {
+      if (unit == null) {
+        return null;
+      }
+      ElementHolder holder = new ElementHolder();
+      ElementBuilder builder = new ElementBuilder(holder);
+      unit.accept(builder);
+      CompilationUnitElementImpl element =
+          new CompilationUnitElementImpl(source.shortName);
+      element.accessors = holder.accessors;
+      element.enums = holder.enums;
+      element.functions = holder.functions;
+      element.source = source;
+      element.librarySource = librarySource;
+      element.typeAliases = holder.typeAliases;
+      element.types = holder.types;
+      element.topLevelVariables = holder.topLevelVariables;
+      unit.element = element;
+      holder.validate();
+      return element;
+    });
+  }
+}
+
+/**
+ * Instances of the class `ConstantVerifier` traverse an AST structure looking for additional
+ * errors and warnings not covered by the parser and resolver. In particular, it looks for errors
+ * and warnings related to constant expressions.
+ */
+class ConstantVerifier extends RecursiveAstVisitor<Object> {
+  /**
+   * The error reporter by which errors will be reported.
+   */
+  final ErrorReporter _errorReporter;
+
+  /**
+   * The type provider used to access the known types.
+   */
+  final TypeProvider _typeProvider;
+
+  /**
+   * The set of variables declared using '-D' on the command line.
+   */
+  final DeclaredVariables declaredVariables;
+
+  /**
+   * The type representing the type 'bool'.
+   */
+  InterfaceType _boolType;
+
+  /**
+   * The type representing the type 'int'.
+   */
+  InterfaceType _intType;
+
+  /**
+   * The type representing the type 'num'.
+   */
+  InterfaceType _numType;
+
+  /**
+   * The type representing the type 'string'.
+   */
+  InterfaceType _stringType;
+
+  /**
+   * The current library that is being analyzed.
+   */
+  final LibraryElement _currentLibrary;
+
+  /**
+   * Initialize a newly created constant verifier.
+   *
+   * @param errorReporter the error reporter by which errors will be reported
+   */
+  ConstantVerifier(this._errorReporter, this._currentLibrary,
+      this._typeProvider, this.declaredVariables) {
+    this._boolType = _typeProvider.boolType;
+    this._intType = _typeProvider.intType;
+    this._numType = _typeProvider.numType;
+    this._stringType = _typeProvider.stringType;
+  }
+
+  @override
+  Object visitAnnotation(Annotation node) {
+    super.visitAnnotation(node);
+    // check annotation creation
+    Element element = node.element;
+    if (element is ConstructorElement) {
+      ConstructorElement constructorElement = element;
+      // should 'const' constructor
+      if (!constructorElement.isConst) {
+        _errorReporter.reportErrorForNode(
+            CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR, node);
+        return null;
+      }
+      // should have arguments
+      ArgumentList argumentList = node.arguments;
+      if (argumentList == null) {
+        _errorReporter.reportErrorForNode(
+            CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS, node);
+        return null;
+      }
+      // arguments should be constants
+      _validateConstantArguments(argumentList);
+    }
+    return null;
+  }
+
+  @override
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    if (node.constKeyword != null) {
+      _validateConstructorInitializers(node);
+      _validateFieldInitializers(node.parent as ClassDeclaration, node);
+    }
+    _validateDefaultValues(node.parameters);
+    return super.visitConstructorDeclaration(node);
+  }
+
+  @override
+  Object visitFunctionExpression(FunctionExpression node) {
+    super.visitFunctionExpression(node);
+    _validateDefaultValues(node.parameters);
+    return null;
+  }
+
+  @override
+  Object visitInstanceCreationExpression(InstanceCreationExpression node) {
+    if (node.isConst) {
+      // We need to evaluate the constant to see if any errors occur during its
+      // evaluation.
+      ConstructorElement constructor = node.staticElement;
+      if (constructor != null) {
+        ConstantEvaluationEngine evaluationEngine =
+            new ConstantEvaluationEngine(_typeProvider, declaredVariables);
+        ConstantVisitor constantVisitor =
+            new ConstantVisitor(evaluationEngine, _errorReporter);
+        evaluationEngine.evaluateConstructorCall(
+            node,
+            node.argumentList.arguments,
+            constructor,
+            constantVisitor,
+            _errorReporter);
+      }
+    }
+    _validateInstanceCreationArguments(node);
+    return super.visitInstanceCreationExpression(node);
+  }
+
+  @override
+  Object visitListLiteral(ListLiteral node) {
+    super.visitListLiteral(node);
+    if (node.constKeyword != null) {
+      DartObjectImpl result;
+      for (Expression element in node.elements) {
+        result =
+            _validate(element, CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT);
+        if (result != null) {
+          _reportErrorIfFromDeferredLibrary(element,
+              CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT_FROM_DEFERRED_LIBRARY);
+        }
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitMapLiteral(MapLiteral node) {
+    super.visitMapLiteral(node);
+    bool isConst = node.constKeyword != null;
+    bool reportEqualKeys = true;
+    HashSet<DartObject> keys = new HashSet<DartObject>();
+    List<Expression> invalidKeys = new List<Expression>();
+    for (MapLiteralEntry entry in node.entries) {
+      Expression key = entry.key;
+      if (isConst) {
+        DartObjectImpl keyResult =
+            _validate(key, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
+        Expression valueExpression = entry.value;
+        DartObjectImpl valueResult = _validate(
+            valueExpression, CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE);
+        if (valueResult != null) {
+          _reportErrorIfFromDeferredLibrary(valueExpression,
+              CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY);
+        }
+        if (keyResult != null) {
+          _reportErrorIfFromDeferredLibrary(key,
+              CompileTimeErrorCode.NON_CONSTANT_MAP_KEY_FROM_DEFERRED_LIBRARY);
+          if (keys.contains(keyResult)) {
+            invalidKeys.add(key);
+          } else {
+            keys.add(keyResult);
+          }
+          DartType type = keyResult.type;
+          if (_implementsEqualsWhenNotAllowed(type)) {
+            _errorReporter.reportErrorForNode(
+                CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS,
+                key,
+                [type.displayName]);
+          }
+        }
+      } else {
+        // Note: we throw the errors away because this isn't actually a const.
+        AnalysisErrorListener errorListener =
+            AnalysisErrorListener.NULL_LISTENER;
+        ErrorReporter subErrorReporter =
+            new ErrorReporter(errorListener, _errorReporter.source);
+        DartObjectImpl result = key.accept(new ConstantVisitor(
+            new ConstantEvaluationEngine(_typeProvider, declaredVariables),
+            subErrorReporter));
+        if (result != null) {
+          if (keys.contains(result)) {
+            invalidKeys.add(key);
+          } else {
+            keys.add(result);
+          }
+        } else {
+          reportEqualKeys = false;
+        }
+      }
+    }
+    if (reportEqualKeys) {
+      for (Expression key in invalidKeys) {
+        _errorReporter.reportErrorForNode(
+            StaticWarningCode.EQUAL_KEYS_IN_MAP, key);
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    super.visitMethodDeclaration(node);
+    _validateDefaultValues(node.parameters);
+    return null;
+  }
+
+  @override
+  Object visitSwitchStatement(SwitchStatement node) {
+    // TODO(paulberry): to minimize error messages, it would be nice to
+    // compare all types with the most popular type rather than the first
+    // type.
+    NodeList<SwitchMember> switchMembers = node.members;
+    bool foundError = false;
+    DartType firstType = null;
+    for (SwitchMember switchMember in switchMembers) {
+      if (switchMember is SwitchCase) {
+        SwitchCase switchCase = switchMember;
+        Expression expression = switchCase.expression;
+        DartObjectImpl caseResult = _validate(
+            expression, CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION);
+        if (caseResult != null) {
+          _reportErrorIfFromDeferredLibrary(expression,
+              CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY);
+          DartObject value = caseResult;
+          if (firstType == null) {
+            firstType = value.type;
+          } else {
+            DartType nType = value.type;
+            if (firstType != nType) {
+              _errorReporter.reportErrorForNode(
+                  CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES,
+                  expression,
+                  [expression.toSource(), firstType.displayName]);
+              foundError = true;
+            }
+          }
+        }
+      }
+    }
+    if (!foundError) {
+      _checkForCaseExpressionTypeImplementsEquals(node, firstType);
+    }
+    return super.visitSwitchStatement(node);
+  }
+
+  @override
+  Object visitVariableDeclaration(VariableDeclaration node) {
+    super.visitVariableDeclaration(node);
+    Expression initializer = node.initializer;
+    if (initializer != null && (node.isConst || node.isFinal)) {
+      VariableElementImpl element = node.element as VariableElementImpl;
+      EvaluationResultImpl result = element.evaluationResult;
+      if (result == null) {
+        // Variables marked "const" should have had their values computed by
+        // ConstantValueComputer.  Other variables will only have had their
+        // values computed if the value was needed (e.g. final variables in a
+        // class containing const constructors).
+        assert(!node.isConst);
+        return null;
+      }
+      _reportErrors(result.errors,
+          CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
+      _reportErrorIfFromDeferredLibrary(initializer,
+          CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY);
+    }
+    return null;
+  }
+
+  /**
+   * This verifies that the passed switch statement does not have a case expression with the
+   * operator '==' overridden.
+   *
+   * @param node the switch statement to evaluate
+   * @param type the common type of all 'case' expressions
+   * @return `true` if and only if an error code is generated on the passed node
+   * See [CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS].
+   */
+  bool _checkForCaseExpressionTypeImplementsEquals(
+      SwitchStatement node, DartType type) {
+    if (!_implementsEqualsWhenNotAllowed(type)) {
+      return false;
+    }
+    // report error
+    _errorReporter.reportErrorForToken(
+        CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS,
+        node.switchKeyword,
+        [type.displayName]);
+    return true;
+  }
+
+  /**
+   * @return `true` if given [Type] implements operator <i>==</i>, and it is not
+   *         <i>int</i> or <i>String</i>.
+   */
+  bool _implementsEqualsWhenNotAllowed(DartType type) {
+    // ignore int or String
+    if (type == null || type == _intType || type == _typeProvider.stringType) {
+      return false;
+    } else if (type == _typeProvider.doubleType) {
+      return true;
+    }
+    // prepare ClassElement
+    Element element = type.element;
+    if (element is! ClassElement) {
+      return false;
+    }
+    ClassElement classElement = element as ClassElement;
+    // lookup for ==
+    MethodElement method =
+        classElement.lookUpConcreteMethod("==", _currentLibrary);
+    if (method == null || method.enclosingElement.type.isObject) {
+      return false;
+    }
+    // there is == that we don't like
+    return true;
+  }
+
+  /**
+   * Given some computed [Expression], this method generates the passed [ErrorCode] on
+   * the node if its' value consists of information from a deferred library.
+   *
+   * @param expression the expression to be tested for a deferred library reference
+   * @param errorCode the error code to be used if the expression is or consists of a reference to a
+   *          deferred library
+   */
+  void _reportErrorIfFromDeferredLibrary(
+      Expression expression, ErrorCode errorCode) {
+    DeferredLibraryReferenceDetector referenceDetector =
+        new DeferredLibraryReferenceDetector();
+    expression.accept(referenceDetector);
+    if (referenceDetector.result) {
+      _errorReporter.reportErrorForNode(errorCode, expression);
+    }
+  }
+
+  /**
+   * Report any errors in the given list. Except for special cases, use the given error code rather
+   * than the one reported in the error.
+   *
+   * @param errors the errors that need to be reported
+   * @param errorCode the error code to be used
+   */
+  void _reportErrors(List<AnalysisError> errors, ErrorCode errorCode) {
+    for (AnalysisError data in errors) {
+      ErrorCode dataErrorCode = data.errorCode;
+      if (identical(dataErrorCode,
+              CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION) ||
+          identical(
+              dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE) ||
+          identical(dataErrorCode,
+              CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING) ||
+          identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL) ||
+          identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_INT) ||
+          identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM) ||
+          identical(dataErrorCode,
+              CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT) ||
+          identical(dataErrorCode,
+              CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH) ||
+          identical(dataErrorCode,
+              CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH) ||
+          identical(dataErrorCode,
+              CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH)) {
+        _errorReporter.reportError(data);
+      } else if (errorCode != null) {
+        _errorReporter.reportError(new AnalysisError(
+            data.source, data.offset, data.length, errorCode));
+      }
+    }
+  }
+
+  /**
+   * Validate that the given expression is a compile time constant. Return the value of the compile
+   * time constant, or `null` if the expression is not a compile time constant.
+   *
+   * @param expression the expression to be validated
+   * @param errorCode the error code to be used if the expression is not a compile time constant
+   * @return the value of the compile time constant
+   */
+  DartObjectImpl _validate(Expression expression, ErrorCode errorCode) {
+    RecordingErrorListener errorListener = new RecordingErrorListener();
+    ErrorReporter subErrorReporter =
+        new ErrorReporter(errorListener, _errorReporter.source);
+    DartObjectImpl result = expression.accept(new ConstantVisitor(
+        new ConstantEvaluationEngine(_typeProvider, declaredVariables),
+        subErrorReporter));
+    _reportErrors(errorListener.errors, errorCode);
+    return result;
+  }
+
+  /**
+   * Validate that if the passed arguments are constant expressions.
+   *
+   * @param argumentList the argument list to evaluate
+   */
+  void _validateConstantArguments(ArgumentList argumentList) {
+    for (Expression argument in argumentList.arguments) {
+      if (argument is NamedExpression) {
+        argument = (argument as NamedExpression).expression;
+      }
+      _validate(
+          argument, CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT);
+    }
+  }
+
+  /**
+   * Validates that the expressions of the given initializers (of a constant constructor) are all
+   * compile time constants.
+   *
+   * @param constructor the constant constructor declaration to validate
+   */
+  void _validateConstructorInitializers(ConstructorDeclaration constructor) {
+    List<ParameterElement> parameterElements =
+        constructor.parameters.parameterElements;
+    NodeList<ConstructorInitializer> initializers = constructor.initializers;
+    for (ConstructorInitializer initializer in initializers) {
+      if (initializer is ConstructorFieldInitializer) {
+        ConstructorFieldInitializer fieldInitializer = initializer;
+        _validateInitializerExpression(
+            parameterElements, fieldInitializer.expression);
+      }
+      if (initializer is RedirectingConstructorInvocation) {
+        RedirectingConstructorInvocation invocation = initializer;
+        _validateInitializerInvocationArguments(
+            parameterElements, invocation.argumentList);
+      }
+      if (initializer is SuperConstructorInvocation) {
+        SuperConstructorInvocation invocation = initializer;
+        _validateInitializerInvocationArguments(
+            parameterElements, invocation.argumentList);
+      }
+    }
+  }
+
+  /**
+   * Validate that the default value associated with each of the parameters in the given list is a
+   * compile time constant.
+   *
+   * @param parameters the list of parameters to be validated
+   */
+  void _validateDefaultValues(FormalParameterList parameters) {
+    if (parameters == null) {
+      return;
+    }
+    for (FormalParameter parameter in parameters.parameters) {
+      if (parameter is DefaultFormalParameter) {
+        DefaultFormalParameter defaultParameter = parameter;
+        Expression defaultValue = defaultParameter.defaultValue;
+        DartObjectImpl result;
+        if (defaultValue == null) {
+          result =
+              new DartObjectImpl(_typeProvider.nullType, NullState.NULL_STATE);
+        } else {
+          result = _validate(
+              defaultValue, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
+          if (result != null) {
+            _reportErrorIfFromDeferredLibrary(defaultValue,
+                CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY);
+          }
+        }
+        VariableElementImpl element = parameter.element as VariableElementImpl;
+        element.evaluationResult = new EvaluationResultImpl(result);
+      }
+    }
+  }
+
+  /**
+   * Validates that the expressions of any field initializers in the class declaration are all
+   * compile time constants. Since this is only required if the class has a constant constructor,
+   * the error is reported at the constructor site.
+   *
+   * @param classDeclaration the class which should be validated
+   * @param errorSite the site at which errors should be reported.
+   */
+  void _validateFieldInitializers(
+      ClassDeclaration classDeclaration, ConstructorDeclaration errorSite) {
+    NodeList<ClassMember> members = classDeclaration.members;
+    for (ClassMember member in members) {
+      if (member is FieldDeclaration) {
+        FieldDeclaration fieldDeclaration = member;
+        if (!fieldDeclaration.isStatic) {
+          for (VariableDeclaration variableDeclaration
+              in fieldDeclaration.fields.variables) {
+            Expression initializer = variableDeclaration.initializer;
+            if (initializer != null) {
+              // Ignore any errors produced during validation--if the constant
+              // can't be eavluated we'll just report a single error.
+              AnalysisErrorListener errorListener =
+                  AnalysisErrorListener.NULL_LISTENER;
+              ErrorReporter subErrorReporter =
+                  new ErrorReporter(errorListener, _errorReporter.source);
+              DartObjectImpl result = initializer.accept(new ConstantVisitor(
+                  new ConstantEvaluationEngine(
+                      _typeProvider, declaredVariables),
+                  subErrorReporter));
+              if (result == null) {
+                _errorReporter.reportErrorForNode(
+                    CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST,
+                    errorSite,
+                    [variableDeclaration.name.name]);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Validates that the given expression is a compile time constant.
+   *
+   * @param parameterElements the elements of parameters of constant constructor, they are
+   *          considered as a valid potentially constant expressions
+   * @param expression the expression to validate
+   */
+  void _validateInitializerExpression(
+      List<ParameterElement> parameterElements, Expression expression) {
+    RecordingErrorListener errorListener = new RecordingErrorListener();
+    ErrorReporter subErrorReporter =
+        new ErrorReporter(errorListener, _errorReporter.source);
+    DartObjectImpl result = expression.accept(
+        new _ConstantVerifier_validateInitializerExpression(_typeProvider,
+            subErrorReporter, this, parameterElements, declaredVariables));
+    _reportErrors(errorListener.errors,
+        CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER);
+    if (result != null) {
+      _reportErrorIfFromDeferredLibrary(expression,
+          CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY);
+    }
+  }
+
+  /**
+   * Validates that all of the arguments of a constructor initializer are compile time constants.
+   *
+   * @param parameterElements the elements of parameters of constant constructor, they are
+   *          considered as a valid potentially constant expressions
+   * @param argumentList the argument list to validate
+   */
+  void _validateInitializerInvocationArguments(
+      List<ParameterElement> parameterElements, ArgumentList argumentList) {
+    if (argumentList == null) {
+      return;
+    }
+    for (Expression argument in argumentList.arguments) {
+      _validateInitializerExpression(parameterElements, argument);
+    }
+  }
+
+  /**
+   * Validate that if the passed instance creation is 'const' then all its arguments are constant
+   * expressions.
+   *
+   * @param node the instance creation evaluate
+   */
+  void _validateInstanceCreationArguments(InstanceCreationExpression node) {
+    if (!node.isConst) {
+      return;
+    }
+    ArgumentList argumentList = node.argumentList;
+    if (argumentList == null) {
+      return;
+    }
+    _validateConstantArguments(argumentList);
+  }
+}
+
+/**
+ * Instances of the class `Dart2JSVerifier` traverse an AST structure looking for hints for
+ * code that will be compiled to JS, such as [HintCode.IS_DOUBLE].
+ */
+class Dart2JSVerifier extends RecursiveAstVisitor<Object> {
+  /**
+   * The name of the `double` type.
+   */
+  static String _DOUBLE_TYPE_NAME = "double";
+
+  /**
+   * The error reporter by which errors will be reported.
+   */
+  final ErrorReporter _errorReporter;
+
+  /**
+   * Create a new instance of the [Dart2JSVerifier].
+   *
+   * @param errorReporter the error reporter
+   */
+  Dart2JSVerifier(this._errorReporter);
+
+  @override
+  Object visitIsExpression(IsExpression node) {
+    _checkForIsDoubleHints(node);
+    return super.visitIsExpression(node);
+  }
+
+  /**
+   * Check for instances of `x is double`, `x is int`, `x is! double` and
+   * `x is! int`.
+   *
+   * @param node the is expression to check
+   * @return `true` if and only if a hint code is generated on the passed node
+   * See [HintCode.IS_DOUBLE],
+   * [HintCode.IS_INT],
+   * [HintCode.IS_NOT_DOUBLE], and
+   * [HintCode.IS_NOT_INT].
+   */
+  bool _checkForIsDoubleHints(IsExpression node) {
+    TypeName typeName = node.type;
+    DartType type = typeName.type;
+    if (type != null && type.element != null) {
+      Element element = type.element;
+      String typeNameStr = element.name;
+      LibraryElement libraryElement = element.library;
+      //      if (typeNameStr.equals(INT_TYPE_NAME) && libraryElement != null
+      //          && libraryElement.isDartCore()) {
+      //        if (node.getNotOperator() == null) {
+      //          errorReporter.reportError(HintCode.IS_INT, node);
+      //        } else {
+      //          errorReporter.reportError(HintCode.IS_NOT_INT, node);
+      //        }
+      //        return true;
+      //      } else
+      if (typeNameStr == _DOUBLE_TYPE_NAME &&
+          libraryElement != null &&
+          libraryElement.isDartCore) {
+        if (node.notOperator == null) {
+          _errorReporter.reportErrorForNode(HintCode.IS_DOUBLE, node);
+        } else {
+          _errorReporter.reportErrorForNode(HintCode.IS_NOT_DOUBLE, node);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+/**
+ * Instances of the class `DeadCodeVerifier` traverse an AST structure looking for cases of
+ * [HintCode.DEAD_CODE].
+ */
+class DeadCodeVerifier extends RecursiveAstVisitor<Object> {
+  /**
+   * The error reporter by which errors will be reported.
+   */
+  final ErrorReporter _errorReporter;
+
+  /**
+   * Create a new instance of the [DeadCodeVerifier].
+   *
+   * @param errorReporter the error reporter
+   */
+  DeadCodeVerifier(this._errorReporter);
+
+  @override
+  Object visitBinaryExpression(BinaryExpression node) {
+    sc.Token operator = node.operator;
+    bool isAmpAmp = operator.type == sc.TokenType.AMPERSAND_AMPERSAND;
+    bool isBarBar = operator.type == sc.TokenType.BAR_BAR;
+    if (isAmpAmp || isBarBar) {
+      Expression lhsCondition = node.leftOperand;
+      if (!_isDebugConstant(lhsCondition)) {
+        EvaluationResultImpl lhsResult = _getConstantBooleanValue(lhsCondition);
+        if (lhsResult != null) {
+          if (lhsResult.value.isTrue && isBarBar) {
+            // report error on else block: true || !e!
+            _errorReporter.reportErrorForNode(
+                HintCode.DEAD_CODE, node.rightOperand);
+            // only visit the LHS:
+            _safelyVisit(lhsCondition);
+            return null;
+          } else if (lhsResult.value.isFalse && isAmpAmp) {
+            // report error on if block: false && !e!
+            _errorReporter.reportErrorForNode(
+                HintCode.DEAD_CODE, node.rightOperand);
+            // only visit the LHS:
+            _safelyVisit(lhsCondition);
+            return null;
+          }
+        }
+      }
+      // How do we want to handle the RHS? It isn't dead code, but "pointless"
+      // or "obscure"...
+//            Expression rhsCondition = node.getRightOperand();
+//            ValidResult rhsResult = getConstantBooleanValue(rhsCondition);
+//            if (rhsResult != null) {
+//              if (rhsResult == ValidResult.RESULT_TRUE && isBarBar) {
+//                // report error on else block: !e! || true
+//                errorReporter.reportError(HintCode.DEAD_CODE, node.getRightOperand());
+//                // only visit the RHS:
+//                safelyVisit(rhsCondition);
+//                return null;
+//              } else if (rhsResult == ValidResult.RESULT_FALSE && isAmpAmp) {
+//                // report error on if block: !e! && false
+//                errorReporter.reportError(HintCode.DEAD_CODE, node.getRightOperand());
+//                // only visit the RHS:
+//                safelyVisit(rhsCondition);
+//                return null;
+//              }
+//            }
+    }
+    return super.visitBinaryExpression(node);
+  }
+
+  /**
+   * For each [Block], this method reports and error on all statements between the end of the
+   * block and the first return statement (assuming there it is not at the end of the block.)
+   *
+   * @param node the block to evaluate
+   */
+  @override
+  Object visitBlock(Block node) {
+    NodeList<Statement> statements = node.statements;
+    _checkForDeadStatementsInNodeList(statements);
+    return null;
+  }
+
+  @override
+  Object visitConditionalExpression(ConditionalExpression node) {
+    Expression conditionExpression = node.condition;
+    _safelyVisit(conditionExpression);
+    if (!_isDebugConstant(conditionExpression)) {
+      EvaluationResultImpl result =
+          _getConstantBooleanValue(conditionExpression);
+      if (result != null) {
+        if (result.value.isTrue) {
+          // report error on else block: true ? 1 : !2!
+          _errorReporter.reportErrorForNode(
+              HintCode.DEAD_CODE, node.elseExpression);
+          _safelyVisit(node.thenExpression);
+          return null;
+        } else {
+          // report error on if block: false ? !1! : 2
+          _errorReporter.reportErrorForNode(
+              HintCode.DEAD_CODE, node.thenExpression);
+          _safelyVisit(node.elseExpression);
+          return null;
+        }
+      }
+    }
+    return super.visitConditionalExpression(node);
+  }
+
+  @override
+  Object visitIfStatement(IfStatement node) {
+    Expression conditionExpression = node.condition;
+    _safelyVisit(conditionExpression);
+    if (!_isDebugConstant(conditionExpression)) {
+      EvaluationResultImpl result =
+          _getConstantBooleanValue(conditionExpression);
+      if (result != null) {
+        if (result.value.isTrue) {
+          // report error on else block: if(true) {} else {!}
+          Statement elseStatement = node.elseStatement;
+          if (elseStatement != null) {
+            _errorReporter.reportErrorForNode(
+                HintCode.DEAD_CODE, elseStatement);
+            _safelyVisit(node.thenStatement);
+            return null;
+          }
+        } else {
+          // report error on if block: if (false) {!} else {}
+          _errorReporter.reportErrorForNode(
+              HintCode.DEAD_CODE, node.thenStatement);
+          _safelyVisit(node.elseStatement);
+          return null;
+        }
+      }
+    }
+    return super.visitIfStatement(node);
+  }
+
+  @override
+  Object visitSwitchCase(SwitchCase node) {
+    _checkForDeadStatementsInNodeList(node.statements);
+    return super.visitSwitchCase(node);
+  }
+
+  @override
+  Object visitSwitchDefault(SwitchDefault node) {
+    _checkForDeadStatementsInNodeList(node.statements);
+    return super.visitSwitchDefault(node);
+  }
+
+  @override
+  Object visitTryStatement(TryStatement node) {
+    _safelyVisit(node.body);
+    _safelyVisit(node.finallyBlock);
+    NodeList<CatchClause> catchClauses = node.catchClauses;
+    int numOfCatchClauses = catchClauses.length;
+    List<DartType> visitedTypes = new List<DartType>();
+    for (int i = 0; i < numOfCatchClauses; i++) {
+      CatchClause catchClause = catchClauses[i];
+      if (catchClause.onKeyword != null) {
+        // on-catch clause found, verify that the exception type is not a
+        // subtype of a previous on-catch exception type
+        TypeName typeName = catchClause.exceptionType;
+        if (typeName != null && typeName.type != null) {
+          DartType currentType = typeName.type;
+          if (currentType.isObject) {
+            // Found catch clause clause that has Object as an exception type,
+            // this is equivalent to having a catch clause that doesn't have an
+            // exception type, visit the block, but generate an error on any
+            // following catch clauses (and don't visit them).
+            _safelyVisit(catchClause);
+            if (i + 1 != numOfCatchClauses) {
+              // this catch clause is not the last in the try statement
+              CatchClause nextCatchClause = catchClauses[i + 1];
+              CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
+              int offset = nextCatchClause.offset;
+              int length = lastCatchClause.end - offset;
+              _errorReporter.reportErrorForOffset(
+                  HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length);
+              return null;
+            }
+          }
+          for (DartType type in visitedTypes) {
+            if (currentType.isSubtypeOf(type)) {
+              CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
+              int offset = catchClause.offset;
+              int length = lastCatchClause.end - offset;
+              _errorReporter.reportErrorForOffset(
+                  HintCode.DEAD_CODE_ON_CATCH_SUBTYPE,
+                  offset,
+                  length,
+                  [currentType.displayName, type.displayName]);
+              return null;
+            }
+          }
+          visitedTypes.add(currentType);
+        }
+        _safelyVisit(catchClause);
+      } else {
+        // Found catch clause clause that doesn't have an exception type,
+        // visit the block, but generate an error on any following catch clauses
+        // (and don't visit them).
+        _safelyVisit(catchClause);
+        if (i + 1 != numOfCatchClauses) {
+          // this catch clause is not the last in the try statement
+          CatchClause nextCatchClause = catchClauses[i + 1];
+          CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
+          int offset = nextCatchClause.offset;
+          int length = lastCatchClause.end - offset;
+          _errorReporter.reportErrorForOffset(
+              HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length);
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitWhileStatement(WhileStatement node) {
+    Expression conditionExpression = node.condition;
+    _safelyVisit(conditionExpression);
+    if (!_isDebugConstant(conditionExpression)) {
+      EvaluationResultImpl result =
+          _getConstantBooleanValue(conditionExpression);
+      if (result != null) {
+        if (result.value.isFalse) {
+          // report error on if block: while (false) {!}
+          _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.body);
+          return null;
+        }
+      }
+    }
+    _safelyVisit(node.body);
+    return null;
+  }
+
+  /**
+   * Given some [NodeList] of [Statement]s, from either a [Block] or
+   * [SwitchMember], this loops through the list in reverse order searching for statements
+   * after a return, unlabeled break or unlabeled continue statement to mark them as dead code.
+   *
+   * @param statements some ordered list of statements in a [Block] or [SwitchMember]
+   */
+  void _checkForDeadStatementsInNodeList(NodeList<Statement> statements) {
+    int size = statements.length;
+    for (int i = 0; i < size; i++) {
+      Statement currentStatement = statements[i];
+      _safelyVisit(currentStatement);
+      bool returnOrBreakingStatement = currentStatement is ReturnStatement ||
+          (currentStatement is BreakStatement &&
+              currentStatement.label == null) ||
+          (currentStatement is ContinueStatement &&
+              currentStatement.label == null);
+      if (returnOrBreakingStatement && i != size - 1) {
+        Statement nextStatement = statements[i + 1];
+        Statement lastStatement = statements[size - 1];
+        int offset = nextStatement.offset;
+        int length = lastStatement.end - offset;
+        _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE, offset, length);
+        return;
+      }
+    }
+  }
+
+  /**
+   * Given some [Expression], this method returns [ValidResult.RESULT_TRUE] if it is
+   * `true`, [ValidResult.RESULT_FALSE] if it is `false`, or `null` if the
+   * expression is not a constant boolean value.
+   *
+   * @param expression the expression to evaluate
+   * @return [ValidResult.RESULT_TRUE] if it is `true`, [ValidResult.RESULT_FALSE]
+   *         if it is `false`, or `null` if the expression is not a constant boolean
+   *         value
+   */
+  EvaluationResultImpl _getConstantBooleanValue(Expression expression) {
+    if (expression is BooleanLiteral) {
+      if (expression.value) {
+        return new EvaluationResultImpl(
+            new DartObjectImpl(null, BoolState.from(true)));
+      } else {
+        return new EvaluationResultImpl(
+            new DartObjectImpl(null, BoolState.from(false)));
+      }
+    }
+    // Don't consider situations where we could evaluate to a constant boolean
+    // expression with the ConstantVisitor
+    // else {
+    // EvaluationResultImpl result = expression.accept(new ConstantVisitor());
+    // if (result == ValidResult.RESULT_TRUE) {
+    // return ValidResult.RESULT_TRUE;
+    // } else if (result == ValidResult.RESULT_FALSE) {
+    // return ValidResult.RESULT_FALSE;
+    // }
+    // return null;
+    // }
+    return null;
+  }
+
+  /**
+   * Return `true` if and only if the passed expression is resolved to a constant variable.
+   *
+   * @param expression some conditional expression
+   * @return `true` if and only if the passed expression is resolved to a constant variable
+   */
+  bool _isDebugConstant(Expression expression) {
+    Element element = null;
+    if (expression is Identifier) {
+      Identifier identifier = expression;
+      element = identifier.staticElement;
+    } else if (expression is PropertyAccess) {
+      PropertyAccess propertyAccess = expression;
+      element = propertyAccess.propertyName.staticElement;
+    }
+    if (element is PropertyAccessorElement) {
+      PropertyInducingElement variable = element.variable;
+      return variable != null && variable.isConst;
+    }
+    return false;
+  }
+
+  /**
+   * If the given node is not `null`, visit this instance of the dead code verifier.
+   *
+   * @param node the node to be visited
+   */
+  void _safelyVisit(AstNode node) {
+    if (node != null) {
+      node.accept(this);
+    }
+  }
+}
+
+/**
+ * Instances of the class `DeclarationResolver` are used to resolve declarations in an AST
+ * structure to already built elements.
+ */
+class DeclarationResolver extends RecursiveAstVisitor<Object> {
+  /**
+   * The compilation unit containing the AST nodes being visited.
+   */
+  CompilationUnitElement _enclosingUnit;
+
+  /**
+   * The function type alias containing the AST nodes being visited, or `null` if we are not
+   * in the scope of a function type alias.
+   */
+  FunctionTypeAliasElement _enclosingAlias;
+
+  /**
+   * The class containing the AST nodes being visited, or `null` if we are not in the scope of
+   * a class.
+   */
+  ClassElement _enclosingClass;
+
+  /**
+   * The method or function containing the AST nodes being visited, or `null` if we are not in
+   * the scope of a method or function.
+   */
+  ExecutableElement _enclosingExecutable;
+
+  /**
+   * The parameter containing the AST nodes being visited, or `null` if we are not in the
+   * scope of a parameter.
+   */
+  ParameterElement _enclosingParameter;
+
+  /**
+   * Resolve the declarations within the given compilation unit to the elements rooted at the given
+   * element.
+   *
+   * @param unit the compilation unit to be resolved
+   * @param element the root of the element model used to resolve the AST nodes
+   */
+  void resolve(CompilationUnit unit, CompilationUnitElement element) {
+    _enclosingUnit = element;
+    unit.element = element;
+    unit.accept(this);
+  }
+
+  @override
+  Object visitCatchClause(CatchClause node) {
+    SimpleIdentifier exceptionParameter = node.exceptionParameter;
+    if (exceptionParameter != null) {
+      List<LocalVariableElement> localVariables =
+          _enclosingExecutable.localVariables;
+      _findIdentifier(localVariables, exceptionParameter);
+      SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
+      if (stackTraceParameter != null) {
+        _findIdentifier(localVariables, stackTraceParameter);
+      }
+    }
+    return super.visitCatchClause(node);
+  }
+
+  @override
+  Object visitClassDeclaration(ClassDeclaration node) {
+    ClassElement outerClass = _enclosingClass;
+    try {
+      SimpleIdentifier className = node.name;
+      _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
+      return super.visitClassDeclaration(node);
+    } finally {
+      _enclosingClass = outerClass;
+    }
+  }
+
+  @override
+  Object visitClassTypeAlias(ClassTypeAlias node) {
+    ClassElement outerClass = _enclosingClass;
+    try {
+      SimpleIdentifier className = node.name;
+      _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
+      return super.visitClassTypeAlias(node);
+    } finally {
+      _enclosingClass = outerClass;
+    }
+  }
+
+  @override
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    ExecutableElement outerExecutable = _enclosingExecutable;
+    try {
+      SimpleIdentifier constructorName = node.name;
+      if (constructorName == null) {
+        _enclosingExecutable = _enclosingClass.unnamedConstructor;
+      } else {
+        _enclosingExecutable =
+            _enclosingClass.getNamedConstructor(constructorName.name);
+        constructorName.staticElement = _enclosingExecutable;
+      }
+      node.element = _enclosingExecutable as ConstructorElement;
+      return super.visitConstructorDeclaration(node);
+    } finally {
+      _enclosingExecutable = outerExecutable;
+    }
+  }
+
+  @override
+  Object visitDeclaredIdentifier(DeclaredIdentifier node) {
+    SimpleIdentifier variableName = node.identifier;
+    _findIdentifier(_enclosingExecutable.localVariables, variableName);
+    return super.visitDeclaredIdentifier(node);
+  }
+
+  @override
+  Object visitDefaultFormalParameter(DefaultFormalParameter node) {
+    SimpleIdentifier parameterName = node.parameter.identifier;
+    ParameterElement element = _getElementForParameter(node, parameterName);
+    Expression defaultValue = node.defaultValue;
+    if (defaultValue != null) {
+      ExecutableElement outerExecutable = _enclosingExecutable;
+      try {
+        if (element == null) {
+          // TODO(brianwilkerson) Report this internal error.
+        } else {
+          _enclosingExecutable = element.initializer;
+        }
+        defaultValue.accept(this);
+      } finally {
+        _enclosingExecutable = outerExecutable;
+      }
+    }
+    ParameterElement outerParameter = _enclosingParameter;
+    try {
+      _enclosingParameter = element;
+      return super.visitDefaultFormalParameter(node);
+    } finally {
+      _enclosingParameter = outerParameter;
+    }
+  }
+
+  @override
+  Object visitEnumDeclaration(EnumDeclaration node) {
+    ClassElement enclosingEnum =
+        _findIdentifier(_enclosingUnit.enums, node.name);
+    List<FieldElement> constants = enclosingEnum.fields;
+    for (EnumConstantDeclaration constant in node.constants) {
+      _findIdentifier(constants, constant.name);
+    }
+    return super.visitEnumDeclaration(node);
+  }
+
+  @override
+  Object visitExportDirective(ExportDirective node) {
+    String uri = _getStringValue(node.uri);
+    if (uri != null) {
+      LibraryElement library = _enclosingUnit.library;
+      ExportElement exportElement = _findExport(
+          library.exports,
+          _enclosingUnit.context.sourceFactory
+              .resolveUri(_enclosingUnit.source, uri));
+      node.element = exportElement;
+    }
+    return super.visitExportDirective(node);
+  }
+
+  @override
+  Object visitFieldFormalParameter(FieldFormalParameter node) {
+    if (node.parent is! DefaultFormalParameter) {
+      SimpleIdentifier parameterName = node.identifier;
+      ParameterElement element = _getElementForParameter(node, parameterName);
+      ParameterElement outerParameter = _enclosingParameter;
+      try {
+        _enclosingParameter = element;
+        return super.visitFieldFormalParameter(node);
+      } finally {
+        _enclosingParameter = outerParameter;
+      }
+    } else {
+      return super.visitFieldFormalParameter(node);
+    }
+  }
+
+  @override
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    ExecutableElement outerExecutable = _enclosingExecutable;
+    try {
+      SimpleIdentifier functionName = node.name;
+      sc.Token property = node.propertyKeyword;
+      if (property == null) {
+        if (_enclosingExecutable != null) {
+          _enclosingExecutable =
+              _findIdentifier(_enclosingExecutable.functions, functionName);
+        } else {
+          _enclosingExecutable =
+              _findIdentifier(_enclosingUnit.functions, functionName);
+        }
+      } else {
+        PropertyAccessorElement accessor =
+            _findIdentifier(_enclosingUnit.accessors, functionName);
+        if ((property as sc.KeywordToken).keyword == sc.Keyword.SET) {
+          accessor = accessor.variable.setter;
+          functionName.staticElement = accessor;
+        }
+        _enclosingExecutable = accessor;
+      }
+      node.functionExpression.element = _enclosingExecutable;
+      return super.visitFunctionDeclaration(node);
+    } finally {
+      _enclosingExecutable = outerExecutable;
+    }
+  }
+
+  @override
+  Object visitFunctionExpression(FunctionExpression node) {
+    if (node.parent is! FunctionDeclaration) {
+      FunctionElement element =
+          _findAtOffset(_enclosingExecutable.functions, node.beginToken.offset);
+      node.element = element;
+    }
+    ExecutableElement outerExecutable = _enclosingExecutable;
+    try {
+      _enclosingExecutable = node.element;
+      return super.visitFunctionExpression(node);
+    } finally {
+      _enclosingExecutable = outerExecutable;
+    }
+  }
+
+  @override
+  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+    FunctionTypeAliasElement outerAlias = _enclosingAlias;
+    try {
+      SimpleIdentifier aliasName = node.name;
+      _enclosingAlias =
+          _findIdentifier(_enclosingUnit.functionTypeAliases, aliasName);
+      return super.visitFunctionTypeAlias(node);
+    } finally {
+      _enclosingAlias = outerAlias;
+    }
+  }
+
+  @override
+  Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
+    if (node.parent is! DefaultFormalParameter) {
+      SimpleIdentifier parameterName = node.identifier;
+      ParameterElement element = _getElementForParameter(node, parameterName);
+      ParameterElement outerParameter = _enclosingParameter;
+      try {
+        _enclosingParameter = element;
+        return super.visitFunctionTypedFormalParameter(node);
+      } finally {
+        _enclosingParameter = outerParameter;
+      }
+    } else {
+      return super.visitFunctionTypedFormalParameter(node);
+    }
+  }
+
+  @override
+  Object visitImportDirective(ImportDirective node) {
+    String uri = _getStringValue(node.uri);
+    if (uri != null) {
+      LibraryElement library = _enclosingUnit.library;
+      ImportElement importElement = _findImport(
+          library.imports,
+          _enclosingUnit.context.sourceFactory
+              .resolveUri(_enclosingUnit.source, uri),
+          node.prefix);
+      node.element = importElement;
+    }
+    return super.visitImportDirective(node);
+  }
+
+  @override
+  Object visitLabeledStatement(LabeledStatement node) {
+    for (Label label in node.labels) {
+      SimpleIdentifier labelName = label.label;
+      _findIdentifier(_enclosingExecutable.labels, labelName);
+    }
+    return super.visitLabeledStatement(node);
+  }
+
+  @override
+  Object visitLibraryDirective(LibraryDirective node) {
+    node.element = _enclosingUnit.library;
+    return super.visitLibraryDirective(node);
+  }
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement outerExecutable = _enclosingExecutable;
+    try {
+      sc.Token property = node.propertyKeyword;
+      SimpleIdentifier methodName = node.name;
+      String nameOfMethod = methodName.name;
+      if (property == null) {
+        _enclosingExecutable = _findWithNameAndOffset(
+            _enclosingClass.methods, nameOfMethod, methodName.offset);
+        methodName.staticElement = _enclosingExecutable;
+      } else {
+        PropertyAccessorElement accessor =
+            _findIdentifier(_enclosingClass.accessors, methodName);
+        if ((property as sc.KeywordToken).keyword == sc.Keyword.SET) {
+          accessor = accessor.variable.setter;
+          methodName.staticElement = accessor;
+        }
+        _enclosingExecutable = accessor;
+      }
+      return super.visitMethodDeclaration(node);
+    } finally {
+      _enclosingExecutable = outerExecutable;
+    }
+  }
+
+  @override
+  Object visitPartDirective(PartDirective node) {
+    String uri = _getStringValue(node.uri);
+    if (uri != null) {
+      Source partSource = _enclosingUnit.context.sourceFactory
+          .resolveUri(_enclosingUnit.source, uri);
+      node.element = _findPart(_enclosingUnit.library.parts, partSource);
+    }
+    return super.visitPartDirective(node);
+  }
+
+  @override
+  Object visitPartOfDirective(PartOfDirective node) {
+    node.element = _enclosingUnit.library;
+    return super.visitPartOfDirective(node);
+  }
+
+  @override
+  Object visitSimpleFormalParameter(SimpleFormalParameter node) {
+    if (node.parent is! DefaultFormalParameter) {
+      SimpleIdentifier parameterName = node.identifier;
+      ParameterElement element = _getElementForParameter(node, parameterName);
+      ParameterElement outerParameter = _enclosingParameter;
+      try {
+        _enclosingParameter = element;
+        return super.visitSimpleFormalParameter(node);
+      } finally {
+        _enclosingParameter = outerParameter;
+      }
+    } else {}
+    return super.visitSimpleFormalParameter(node);
+  }
+
+  @override
+  Object visitSwitchCase(SwitchCase node) {
+    for (Label label in node.labels) {
+      SimpleIdentifier labelName = label.label;
+      _findIdentifier(_enclosingExecutable.labels, labelName);
+    }
+    return super.visitSwitchCase(node);
+  }
+
+  @override
+  Object visitSwitchDefault(SwitchDefault node) {
+    for (Label label in node.labels) {
+      SimpleIdentifier labelName = label.label;
+      _findIdentifier(_enclosingExecutable.labels, labelName);
+    }
+    return super.visitSwitchDefault(node);
+  }
+
+  @override
+  Object visitTypeParameter(TypeParameter node) {
+    SimpleIdentifier parameterName = node.name;
+    if (_enclosingClass != null) {
+      _findIdentifier(_enclosingClass.typeParameters, parameterName);
+    } else if (_enclosingAlias != null) {
+      _findIdentifier(_enclosingAlias.typeParameters, parameterName);
+    }
+    return super.visitTypeParameter(node);
+  }
+
+  @override
+  Object visitVariableDeclaration(VariableDeclaration node) {
+    VariableElement element = null;
+    SimpleIdentifier variableName = node.name;
+    if (_enclosingExecutable != null) {
+      element =
+          _findIdentifier(_enclosingExecutable.localVariables, variableName);
+    }
+    if (element == null && _enclosingClass != null) {
+      element = _findIdentifier(_enclosingClass.fields, variableName);
+    }
+    if (element == null && _enclosingUnit != null) {
+      element = _findIdentifier(_enclosingUnit.topLevelVariables, variableName);
+    }
+    Expression initializer = node.initializer;
+    if (initializer != null) {
+      ExecutableElement outerExecutable = _enclosingExecutable;
+      try {
+        if (element == null) {
+          // TODO(brianwilkerson) Report this internal error.
+        } else {
+          _enclosingExecutable = element.initializer;
+        }
+        return super.visitVariableDeclaration(node);
+      } finally {
+        _enclosingExecutable = outerExecutable;
+      }
+    }
+    return super.visitVariableDeclaration(node);
+  }
+
+  /**
+   * Return the element in the given array of elements that was created for the declaration at the
+   * given offset. This method should only be used when there is no name
+   *
+   * @param elements the elements of the appropriate kind that exist in the current context
+   * @param offset the offset of the name of the element to be returned
+   * @return the element at the given offset
+   */
+  Element _findAtOffset(List<Element> elements, int offset) =>
+      _findWithNameAndOffset(elements, "", offset);
+
+  /**
+   * Return the export element from the given array whose library has the given source, or
+   * `null` if there is no such export.
+   *
+   * @param exports the export elements being searched
+   * @param source the source of the library associated with the export element to being searched
+   *          for
+   * @return the export element whose library has the given source
+   */
+  ExportElement _findExport(List<ExportElement> exports, Source source) {
+    for (ExportElement export in exports) {
+      if (export.exportedLibrary.source == source) {
+        return export;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the element in the given array of elements that was created for the declaration with the
+   * given name.
+   *
+   * @param elements the elements of the appropriate kind that exist in the current context
+   * @param identifier the name node in the declaration of the element to be returned
+   * @return the element created for the declaration with the given name
+   */
+  Element _findIdentifier(List<Element> elements, SimpleIdentifier identifier) {
+    Element element =
+        _findWithNameAndOffset(elements, identifier.name, identifier.offset);
+    identifier.staticElement = element;
+    return element;
+  }
+
+  /**
+   * Return the import element from the given array whose library has the given source and that has
+   * the given prefix, or `null` if there is no such import.
+   *
+   * @param imports the import elements being searched
+   * @param source the source of the library associated with the import element to being searched
+   *          for
+   * @param prefix the prefix with which the library was imported
+   * @return the import element whose library has the given source and prefix
+   */
+  ImportElement _findImport(
+      List<ImportElement> imports, Source source, SimpleIdentifier prefix) {
+    for (ImportElement element in imports) {
+      if (element.importedLibrary.source == source) {
+        PrefixElement prefixElement = element.prefix;
+        if (prefix == null) {
+          if (prefixElement == null) {
+            return element;
+          }
+        } else {
+          if (prefixElement != null &&
+              prefix.name == prefixElement.displayName) {
+            return element;
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the element for the part with the given source, or `null` if there is no element
+   * for the given source.
+   *
+   * @param parts the elements for the parts
+   * @param partSource the source for the part whose element is to be returned
+   * @return the element for the part with the given source
+   */
+  CompilationUnitElement _findPart(
+      List<CompilationUnitElement> parts, Source partSource) {
+    for (CompilationUnitElement part in parts) {
+      if (part.source == partSource) {
+        return part;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the element in the given array of elements that was created for the declaration with the
+   * given name at the given offset.
+   *
+   * @param elements the elements of the appropriate kind that exist in the current context
+   * @param name the name of the element to be returned
+   * @param offset the offset of the name of the element to be returned
+   * @return the element with the given name and offset
+   */
+  Element _findWithNameAndOffset(
+      List<Element> elements, String name, int offset) {
+    for (Element element in elements) {
+      if (element.nameOffset == offset && element.displayName == name) {
+        return element;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Search the most closely enclosing list of parameters for a parameter with the given name.
+   *
+   * @param node the node defining the parameter with the given name
+   * @param parameterName the name of the parameter being searched for
+   * @return the element representing the parameter with that name
+   */
+  ParameterElement _getElementForParameter(
+      FormalParameter node, SimpleIdentifier parameterName) {
+    List<ParameterElement> parameters = null;
+    if (_enclosingParameter != null) {
+      parameters = _enclosingParameter.parameters;
+    }
+    if (parameters == null && _enclosingExecutable != null) {
+      parameters = _enclosingExecutable.parameters;
+    }
+    if (parameters == null && _enclosingAlias != null) {
+      parameters = _enclosingAlias.parameters;
+    }
+    ParameterElement element =
+        parameters == null ? null : _findIdentifier(parameters, parameterName);
+    if (element == null) {
+      StringBuffer buffer = new StringBuffer();
+      buffer.writeln("Invalid state found in the Analysis Engine:");
+      buffer.writeln(
+          "DeclarationResolver.getElementForParameter() is visiting a parameter that does not appear to be in a method or function.");
+      buffer.writeln("Ancestors:");
+      AstNode parent = node.parent;
+      while (parent != null) {
+        buffer.writeln(parent.runtimeType.toString());
+        buffer.writeln("---------");
+        parent = parent.parent;
+      }
+      AnalysisEngine.instance.logger.logError(buffer.toString(),
+          new CaughtException(new AnalysisException(), null));
+    }
+    return element;
+  }
+
+  /**
+   * Return the value of the given string literal, or `null` if the string is not a constant
+   * string without any string interpolation.
+   *
+   * @param literal the string literal whose value is to be returned
+   * @return the value of the given string literal
+   */
+  String _getStringValue(StringLiteral literal) {
+    if (literal is StringInterpolation) {
+      return null;
+    }
+    return literal.stringValue;
+  }
+}
+
+/**
+ * Instances of the class `ElementBuilder` traverse an AST structure and build the element
+ * model representing the AST structure.
+ */
+class ElementBuilder extends RecursiveAstVisitor<Object> {
+  /**
+   * The element holder associated with the element that is currently being built.
+   */
+  ElementHolder _currentHolder;
+
+  /**
+   * A flag indicating whether a variable declaration is in the context of a field declaration.
+   */
+  bool _inFieldContext = false;
+
+  /**
+   * A flag indicating whether a variable declaration is within the body of a method or function.
+   */
+  bool _inFunction = false;
+
+  /**
+   * A flag indicating whether the class currently being visited can be used as a mixin.
+   */
+  bool _isValidMixin = false;
+
+  /**
+   * A collection holding the function types defined in a class that need to have their type
+   * arguments set to the types of the type parameters for the class, or `null` if we are not
+   * currently processing nodes within a class.
+   */
+  List<FunctionTypeImpl> _functionTypesToFix = null;
+
+  /**
+   * A table mapping field names to field elements for the fields defined in the current class, or
+   * `null` if we are not in the scope of a class.
+   */
+  HashMap<String, FieldElement> _fieldMap;
+
+  /**
+   * Initialize a newly created element builder to build the elements for a compilation unit.
+   *
+   * @param initialHolder the element holder associated with the compilation unit being built
+   */
+  ElementBuilder(ElementHolder initialHolder) {
+    _currentHolder = initialHolder;
+  }
+
+  @override
+  Object visitBlock(Block node) {
+    bool wasInField = _inFieldContext;
+    _inFieldContext = false;
+    try {
+      node.visitChildren(this);
+    } finally {
+      _inFieldContext = wasInField;
+    }
+    return null;
+  }
+
+  @override
+  Object visitCatchClause(CatchClause node) {
+    SimpleIdentifier exceptionParameter = node.exceptionParameter;
+    if (exceptionParameter != null) {
+      // exception
+      LocalVariableElementImpl exception =
+          new LocalVariableElementImpl.forNode(exceptionParameter);
+      if (node.exceptionType == null) {
+        exception.hasImplicitType = true;
+      }
+      _currentHolder.addLocalVariable(exception);
+      exceptionParameter.staticElement = exception;
+      // stack trace
+      SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
+      if (stackTraceParameter != null) {
+        LocalVariableElementImpl stackTrace =
+            new LocalVariableElementImpl.forNode(stackTraceParameter);
+        _currentHolder.addLocalVariable(stackTrace);
+        stackTraceParameter.staticElement = stackTrace;
+      }
+    }
+    return super.visitCatchClause(node);
+  }
+
+  @override
+  Object visitClassDeclaration(ClassDeclaration node) {
+    ElementHolder holder = new ElementHolder();
+    _isValidMixin = true;
+    _functionTypesToFix = new List<FunctionTypeImpl>();
+    //
+    // Process field declarations before constructors and methods so that field
+    // formal parameters can be correctly resolved to their fields.
+    //
+    ElementHolder previousHolder = _currentHolder;
+    _currentHolder = holder;
+    try {
+      List<ClassMember> nonFields = new List<ClassMember>();
+      node.visitChildren(
+          new _ElementBuilder_visitClassDeclaration(this, nonFields));
+      _buildFieldMap(holder.fieldsWithoutFlushing);
+      int count = nonFields.length;
+      for (int i = 0; i < count; i++) {
+        nonFields[i].accept(this);
+      }
+    } finally {
+      _currentHolder = previousHolder;
+    }
+    SimpleIdentifier className = node.name;
+    ClassElementImpl element = new ClassElementImpl.forNode(className);
+    List<TypeParameterElement> typeParameters = holder.typeParameters;
+    List<DartType> typeArguments = _createTypeParameterTypes(typeParameters);
+    InterfaceTypeImpl interfaceType = new InterfaceTypeImpl(element);
+    interfaceType.typeArguments = typeArguments;
+    element.type = interfaceType;
+    List<ConstructorElement> constructors = holder.constructors;
+    if (constructors.length == 0) {
+      //
+      // Create the default constructor.
+      //
+      constructors = _createDefaultConstructors(interfaceType);
+    }
+    element.abstract = node.isAbstract;
+    element.accessors = holder.accessors;
+    element.constructors = constructors;
+    element.fields = holder.fields;
+    element.methods = holder.methods;
+    element.typeParameters = typeParameters;
+    element.validMixin = _isValidMixin;
+    int functionTypeCount = _functionTypesToFix.length;
+    for (int i = 0; i < functionTypeCount; i++) {
+      _functionTypesToFix[i].typeArguments = typeArguments;
+    }
+    _functionTypesToFix = null;
+    _currentHolder.addType(element);
+    className.staticElement = element;
+    _fieldMap = null;
+    holder.validate();
+    return null;
+  }
+
+  /**
+   * Implementation of this method should be synchronized with
+   * [visitClassDeclaration].
+   */
+  void visitClassDeclarationIncrementally(ClassDeclaration node) {
+    //
+    // Process field declarations before constructors and methods so that field
+    // formal parameters can be correctly resolved to their fields.
+    //
+    ClassElement classElement = node.element;
+    _buildFieldMap(classElement.fields);
+  }
+
+  @override
+  Object visitClassTypeAlias(ClassTypeAlias node) {
+    ElementHolder holder = new ElementHolder();
+    _functionTypesToFix = new List<FunctionTypeImpl>();
+    _visitChildren(holder, node);
+    SimpleIdentifier className = node.name;
+    ClassElementImpl element = new ClassElementImpl.forNode(className);
+    element.abstract = node.abstractKeyword != null;
+    element.mixinApplication = true;
+    List<TypeParameterElement> typeParameters = holder.typeParameters;
+    element.typeParameters = typeParameters;
+    List<DartType> typeArguments = _createTypeParameterTypes(typeParameters);
+    InterfaceTypeImpl interfaceType = new InterfaceTypeImpl(element);
+    interfaceType.typeArguments = typeArguments;
+    element.type = interfaceType;
+    // set default constructor
+    for (FunctionTypeImpl functionType in _functionTypesToFix) {
+      functionType.typeArguments = typeArguments;
+    }
+    _functionTypesToFix = null;
+    _currentHolder.addType(element);
+    className.staticElement = element;
+    holder.validate();
+    return null;
+  }
+
+  @override
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    _isValidMixin = false;
+    ElementHolder holder = new ElementHolder();
+    bool wasInFunction = _inFunction;
+    _inFunction = true;
+    try {
+      _visitChildren(holder, node);
+    } finally {
+      _inFunction = wasInFunction;
+    }
+    FunctionBody body = node.body;
+    SimpleIdentifier constructorName = node.name;
+    ConstructorElementImpl element =
+        new ConstructorElementImpl.forNode(constructorName);
+    if (node.externalKeyword != null) {
+      element.external = true;
+    }
+    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;
+    if (body.isAsynchronous) {
+      element.asynchronous = true;
+    }
+    if (body.isGenerator) {
+      element.generator = true;
+    }
+    _currentHolder.addConstructor(element);
+    node.element = element;
+    if (constructorName == null) {
+      Identifier returnType = node.returnType;
+      if (returnType != null) {
+        element.nameOffset = returnType.offset;
+        element.nameEnd = returnType.end;
+      }
+    } else {
+      constructorName.staticElement = element;
+      element.periodOffset = node.period.offset;
+      element.nameEnd = constructorName.end;
+    }
+    holder.validate();
+    return null;
+  }
+
+  @override
+  Object visitDeclaredIdentifier(DeclaredIdentifier node) {
+    SimpleIdentifier variableName = node.identifier;
+    LocalVariableElementImpl element =
+        new LocalVariableElementImpl.forNode(variableName);
+    ForEachStatement statement = node.parent as ForEachStatement;
+    int declarationEnd = node.offset + node.length;
+    int statementEnd = statement.offset + statement.length;
+    element.setVisibleRange(declarationEnd, statementEnd - declarationEnd - 1);
+    element.const3 = node.isConst;
+    element.final2 = node.isFinal;
+    if (node.type == null) {
+      element.hasImplicitType = true;
+    }
+    _currentHolder.addLocalVariable(element);
+    variableName.staticElement = element;
+    return super.visitDeclaredIdentifier(node);
+  }
+
+  @override
+  Object visitDefaultFormalParameter(DefaultFormalParameter node) {
+    ElementHolder holder = new ElementHolder();
+    NormalFormalParameter normalParameter = node.parameter;
+    SimpleIdentifier parameterName = normalParameter.identifier;
+    ParameterElementImpl parameter;
+    if (normalParameter is FieldFormalParameter) {
+      parameter = new DefaultFieldFormalParameterElementImpl(parameterName);
+      FieldElement field =
+          _fieldMap == null ? null : _fieldMap[parameterName.name];
+      if (field != null) {
+        (parameter as DefaultFieldFormalParameterElementImpl).field = field;
+      }
+    } else {
+      parameter = new DefaultParameterElementImpl(parameterName);
+    }
+    parameter.const3 = node.isConst;
+    parameter.final2 = node.isFinal;
+    parameter.parameterKind = node.kind;
+    // set initializer, default value range
+    Expression defaultValue = node.defaultValue;
+    if (defaultValue != null) {
+      _visit(holder, defaultValue);
+      FunctionElementImpl initializer =
+          new FunctionElementImpl.forOffset(defaultValue.beginToken.offset);
+      initializer.functions = holder.functions;
+      initializer.labels = holder.labels;
+      initializer.localVariables = holder.localVariables;
+      initializer.parameters = holder.parameters;
+      initializer.synthetic = true;
+      parameter.initializer = initializer;
+      parameter.defaultValueCode = defaultValue.toSource();
+    }
+    // visible range
+    _setParameterVisibleRange(node, parameter);
+    if (normalParameter is SimpleFormalParameter &&
+        normalParameter.type == null) {
+      parameter.hasImplicitType = true;
+    }
+    _currentHolder.addParameter(parameter);
+    parameterName.staticElement = parameter;
+    normalParameter.accept(this);
+    holder.validate();
+    return null;
+  }
+
+  @override
+  Object visitEnumDeclaration(EnumDeclaration node) {
+    SimpleIdentifier enumName = node.name;
+    ClassElementImpl enumElement = new ClassElementImpl.forNode(enumName);
+    enumElement.enum2 = true;
+    InterfaceTypeImpl enumType = new InterfaceTypeImpl(enumElement);
+    enumElement.type = enumType;
+    // The equivalent code for enums in the spec shows a single constructor,
+    // but that constructor is not callable (since it is a compile-time error
+    // to subclass, mix-in, implement, or explicitly instantiate an enum).  So
+    // we represent this as having no constructors.
+    enumElement.constructors = ConstructorElement.EMPTY_LIST;
+    _currentHolder.addEnum(enumElement);
+    enumName.staticElement = enumElement;
+    return super.visitEnumDeclaration(node);
+  }
+
+  @override
+  Object visitFieldDeclaration(FieldDeclaration node) {
+    bool wasInField = _inFieldContext;
+    _inFieldContext = true;
+    try {
+      node.visitChildren(this);
+    } finally {
+      _inFieldContext = wasInField;
+    }
+    return null;
+  }
+
+  @override
+  Object visitFieldFormalParameter(FieldFormalParameter node) {
+    if (node.parent is! DefaultFormalParameter) {
+      SimpleIdentifier parameterName = node.identifier;
+      FieldElement field =
+          _fieldMap == null ? null : _fieldMap[parameterName.name];
+      FieldFormalParameterElementImpl parameter =
+          new FieldFormalParameterElementImpl(parameterName);
+      parameter.const3 = node.isConst;
+      parameter.final2 = node.isFinal;
+      parameter.parameterKind = node.kind;
+      if (field != null) {
+        parameter.field = field;
+      }
+      _currentHolder.addParameter(parameter);
+      parameterName.staticElement = parameter;
+    }
+    //
+    // The children of this parameter include any parameters defined on the type
+    // of this parameter.
+    //
+    ElementHolder holder = new ElementHolder();
+    _visitChildren(holder, node);
+    ParameterElementImpl element = node.element;
+    element.parameters = holder.parameters;
+    element.typeParameters = holder.typeParameters;
+    holder.validate();
+    return null;
+  }
+
+  @override
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    FunctionExpression expression = node.functionExpression;
+    if (expression != null) {
+      ElementHolder holder = new ElementHolder();
+      bool wasInFunction = _inFunction;
+      _inFunction = true;
+      try {
+        _visitChildren(holder, node);
+      } finally {
+        _inFunction = wasInFunction;
+      }
+      FunctionBody body = expression.body;
+      sc.Token property = node.propertyKeyword;
+      if (property == null || _inFunction) {
+        SimpleIdentifier functionName = node.name;
+        FunctionElementImpl element =
+            new FunctionElementImpl.forNode(functionName);
+        if (node.externalKeyword != null) {
+          element.external = true;
+        }
+        element.functions = holder.functions;
+        element.labels = holder.labels;
+        element.localVariables = holder.localVariables;
+        element.parameters = holder.parameters;
+        element.typeParameters = holder.typeParameters;
+        if (body.isAsynchronous) {
+          element.asynchronous = true;
+        }
+        if (body.isGenerator) {
+          element.generator = true;
+        }
+        if (_inFunction) {
+          Block enclosingBlock = node.getAncestor((node) => node is Block);
+          if (enclosingBlock != null) {
+            int functionEnd = node.offset + node.length;
+            int blockEnd = enclosingBlock.offset + enclosingBlock.length;
+            element.setVisibleRange(functionEnd, blockEnd - functionEnd - 1);
+          }
+        }
+        if (node.returnType == null) {
+          element.hasImplicitReturnType = true;
+        }
+        _currentHolder.addFunction(element);
+        expression.element = element;
+        functionName.staticElement = element;
+      } else {
+        SimpleIdentifier propertyNameNode = node.name;
+        if (propertyNameNode == null) {
+          // TODO(brianwilkerson) Report this internal error.
+          return null;
+        }
+        String propertyName = propertyNameNode.name;
+        TopLevelVariableElementImpl variable = _currentHolder
+            .getTopLevelVariable(propertyName) as TopLevelVariableElementImpl;
+        if (variable == null) {
+          variable = new TopLevelVariableElementImpl(node.name.name, -1);
+          variable.final2 = true;
+          variable.synthetic = true;
+          _currentHolder.addTopLevelVariable(variable);
+        }
+        if (node.isGetter) {
+          PropertyAccessorElementImpl getter =
+              new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          if (node.externalKeyword != null) {
+            getter.external = true;
+          }
+          getter.functions = holder.functions;
+          getter.labels = holder.labels;
+          getter.localVariables = holder.localVariables;
+          if (body.isAsynchronous) {
+            getter.asynchronous = true;
+          }
+          if (body.isGenerator) {
+            getter.generator = true;
+          }
+          getter.variable = variable;
+          getter.getter = true;
+          getter.static = true;
+          variable.getter = getter;
+          if (node.returnType == null) {
+            getter.hasImplicitReturnType = true;
+          }
+          _currentHolder.addAccessor(getter);
+          expression.element = getter;
+          propertyNameNode.staticElement = getter;
+        } else {
+          PropertyAccessorElementImpl setter =
+              new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          if (node.externalKeyword != null) {
+            setter.external = true;
+          }
+          setter.functions = holder.functions;
+          setter.labels = holder.labels;
+          setter.localVariables = holder.localVariables;
+          setter.parameters = holder.parameters;
+          if (body.isAsynchronous) {
+            setter.asynchronous = true;
+          }
+          if (body.isGenerator) {
+            setter.generator = true;
+          }
+          setter.variable = variable;
+          setter.setter = true;
+          setter.static = true;
+          variable.setter = setter;
+          variable.final2 = false;
+          _currentHolder.addAccessor(setter);
+          expression.element = setter;
+          propertyNameNode.staticElement = setter;
+        }
+      }
+      holder.validate();
+    }
+    return null;
+  }
+
+  @override
+  Object visitFunctionExpression(FunctionExpression node) {
+    if (node.parent is FunctionDeclaration) {
+      // visitFunctionDeclaration has already created the element for the
+      // declaration.  We just need to visit children.
+      return super.visitFunctionExpression(node);
+    }
+    ElementHolder holder = new ElementHolder();
+    bool wasInFunction = _inFunction;
+    _inFunction = true;
+    try {
+      _visitChildren(holder, node);
+    } finally {
+      _inFunction = wasInFunction;
+    }
+    FunctionBody body = node.body;
+    FunctionElementImpl element =
+        new FunctionElementImpl.forOffset(node.beginToken.offset);
+    element.functions = holder.functions;
+    element.labels = holder.labels;
+    element.localVariables = holder.localVariables;
+    element.parameters = holder.parameters;
+    element.typeParameters = holder.typeParameters;
+    if (body.isAsynchronous) {
+      element.asynchronous = true;
+    }
+    if (body.isGenerator) {
+      element.generator = true;
+    }
+    if (_inFunction) {
+      Block enclosingBlock = node.getAncestor((node) => node is Block);
+      if (enclosingBlock != null) {
+        int functionEnd = node.offset + node.length;
+        int blockEnd = enclosingBlock.offset + enclosingBlock.length;
+        element.setVisibleRange(functionEnd, blockEnd - functionEnd - 1);
+      }
+    }
+    FunctionTypeImpl type = new FunctionTypeImpl(element);
+    if (_functionTypesToFix != null) {
+      _functionTypesToFix.add(type);
+    }
+    element.type = type;
+    element.hasImplicitReturnType = true;
+    _currentHolder.addFunction(element);
+    node.element = element;
+    holder.validate();
+    return null;
+  }
+
+  @override
+  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+    ElementHolder holder = new ElementHolder();
+    _visitChildren(holder, node);
+    SimpleIdentifier aliasName = node.name;
+    List<ParameterElement> parameters = holder.parameters;
+    List<TypeParameterElement> typeParameters = holder.typeParameters;
+    FunctionTypeAliasElementImpl element =
+        new FunctionTypeAliasElementImpl.forNode(aliasName);
+    element.parameters = parameters;
+    element.typeParameters = typeParameters;
+    FunctionTypeImpl type = new FunctionTypeImpl.forTypedef(element);
+    type.typeArguments = _createTypeParameterTypes(typeParameters);
+    element.type = type;
+    _currentHolder.addTypeAlias(element);
+    aliasName.staticElement = element;
+    holder.validate();
+    return null;
+  }
+
+  @override
+  Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
+    if (node.parent is! DefaultFormalParameter) {
+      SimpleIdentifier parameterName = node.identifier;
+      ParameterElementImpl parameter =
+          new ParameterElementImpl.forNode(parameterName);
+      parameter.parameterKind = node.kind;
+      _setParameterVisibleRange(node, parameter);
+      _currentHolder.addParameter(parameter);
+      parameterName.staticElement = parameter;
+    }
+    //
+    // The children of this parameter include any parameters defined on the type
+    //of this parameter.
+    //
+    ElementHolder holder = new ElementHolder();
+    _visitChildren(holder, node);
+    ParameterElementImpl element = node.element;
+    element.parameters = holder.parameters;
+    element.typeParameters = holder.typeParameters;
+    holder.validate();
+    return null;
+  }
+
+  @override
+  Object visitLabeledStatement(LabeledStatement node) {
+    bool onSwitchStatement = node.statement is SwitchStatement;
+    for (Label label in node.labels) {
+      SimpleIdentifier labelName = label.label;
+      LabelElementImpl element =
+          new LabelElementImpl(labelName, onSwitchStatement, false);
+      _currentHolder.addLabel(element);
+      labelName.staticElement = element;
+    }
+    return super.visitLabeledStatement(node);
+  }
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    try {
+      ElementHolder holder = new ElementHolder();
+      bool wasInFunction = _inFunction;
+      _inFunction = true;
+      try {
+        _visitChildren(holder, node);
+      } finally {
+        _inFunction = wasInFunction;
+      }
+      bool isStatic = node.isStatic;
+      sc.Token property = node.propertyKeyword;
+      FunctionBody body = node.body;
+      if (property == null) {
+        SimpleIdentifier methodName = node.name;
+        String nameOfMethod = methodName.name;
+        if (nameOfMethod == sc.TokenType.MINUS.lexeme &&
+            node.parameters.parameters.length == 0) {
+          nameOfMethod = "unary-";
+        }
+        MethodElementImpl element =
+            new MethodElementImpl(nameOfMethod, methodName.offset);
+        element.abstract = node.isAbstract;
+        if (node.externalKeyword != null) {
+          element.external = true;
+        }
+        element.functions = holder.functions;
+        element.labels = holder.labels;
+        element.localVariables = holder.localVariables;
+        element.parameters = holder.parameters;
+        element.static = isStatic;
+        element.typeParameters = holder.typeParameters;
+        if (body.isAsynchronous) {
+          element.asynchronous = true;
+        }
+        if (body.isGenerator) {
+          element.generator = true;
+        }
+        if (node.returnType == null) {
+          element.hasImplicitReturnType = true;
+        }
+        _currentHolder.addMethod(element);
+        methodName.staticElement = element;
+      } else {
+        SimpleIdentifier propertyNameNode = node.name;
+        String propertyName = propertyNameNode.name;
+        FieldElementImpl field =
+            _currentHolder.getField(propertyName) as FieldElementImpl;
+        if (field == null) {
+          field = new FieldElementImpl(node.name.name, -1);
+          field.final2 = true;
+          field.static = isStatic;
+          field.synthetic = true;
+          _currentHolder.addField(field);
+        }
+        if (node.isGetter) {
+          PropertyAccessorElementImpl getter =
+              new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          if (node.externalKeyword != null) {
+            getter.external = true;
+          }
+          getter.functions = holder.functions;
+          getter.labels = holder.labels;
+          getter.localVariables = holder.localVariables;
+          if (body.isAsynchronous) {
+            getter.asynchronous = true;
+          }
+          if (body.isGenerator) {
+            getter.generator = true;
+          }
+          getter.variable = field;
+          getter.abstract = node.isAbstract;
+          getter.getter = true;
+          getter.static = isStatic;
+          field.getter = getter;
+          if (node.returnType == null) {
+            getter.hasImplicitReturnType = true;
+          }
+          _currentHolder.addAccessor(getter);
+          propertyNameNode.staticElement = getter;
+        } else {
+          PropertyAccessorElementImpl setter =
+              new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          if (node.externalKeyword != null) {
+            setter.external = true;
+          }
+          setter.functions = holder.functions;
+          setter.labels = holder.labels;
+          setter.localVariables = holder.localVariables;
+          setter.parameters = holder.parameters;
+          if (body.isAsynchronous) {
+            setter.asynchronous = true;
+          }
+          if (body.isGenerator) {
+            setter.generator = true;
+          }
+          setter.variable = field;
+          setter.abstract = node.isAbstract;
+          setter.setter = true;
+          setter.static = isStatic;
+          field.setter = setter;
+          field.final2 = false;
+          _currentHolder.addAccessor(setter);
+          propertyNameNode.staticElement = setter;
+        }
+      }
+      holder.validate();
+    } catch (exception, stackTrace) {
+      if (node.name.staticElement == null) {
+        ClassDeclaration classNode =
+            node.getAncestor((node) => node is ClassDeclaration);
+        StringBuffer buffer = new StringBuffer();
+        buffer.write("The element for the method ");
+        buffer.write(node.name);
+        buffer.write(" in ");
+        buffer.write(classNode.name);
+        buffer.write(" was not set while trying to build the element model.");
+        AnalysisEngine.instance.logger.logError(
+            buffer.toString(), new CaughtException(exception, stackTrace));
+      } else {
+        String message =
+            "Exception caught in ElementBuilder.visitMethodDeclaration()";
+        AnalysisEngine.instance.logger
+            .logError(message, new CaughtException(exception, stackTrace));
+      }
+    } finally {
+      if (node.name.staticElement == null) {
+        ClassDeclaration classNode =
+            node.getAncestor((node) => node is ClassDeclaration);
+        StringBuffer buffer = new StringBuffer();
+        buffer.write("The element for the method ");
+        buffer.write(node.name);
+        buffer.write(" in ");
+        buffer.write(classNode.name);
+        buffer.write(" was not set while trying to resolve types.");
+        AnalysisEngine.instance.logger.logError(
+            buffer.toString(),
+            new CaughtException(
+                new AnalysisException(buffer.toString()), null));
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitSimpleFormalParameter(SimpleFormalParameter node) {
+    if (node.parent is! DefaultFormalParameter) {
+      SimpleIdentifier parameterName = node.identifier;
+      ParameterElementImpl parameter =
+          new ParameterElementImpl.forNode(parameterName);
+      parameter.const3 = node.isConst;
+      parameter.final2 = node.isFinal;
+      parameter.parameterKind = node.kind;
+      _setParameterVisibleRange(node, parameter);
+      if (node.type == null) {
+        parameter.hasImplicitType = true;
+      }
+      _currentHolder.addParameter(parameter);
+      parameterName.staticElement = parameter;
+    }
+    return super.visitSimpleFormalParameter(node);
+  }
+
+  @override
+  Object visitSuperExpression(SuperExpression node) {
+    _isValidMixin = false;
+    return super.visitSuperExpression(node);
+  }
+
+  @override
+  Object visitSwitchCase(SwitchCase node) {
+    for (Label label in node.labels) {
+      SimpleIdentifier labelName = label.label;
+      LabelElementImpl element = new LabelElementImpl(labelName, false, true);
+      _currentHolder.addLabel(element);
+      labelName.staticElement = element;
+    }
+    return super.visitSwitchCase(node);
+  }
+
+  @override
+  Object visitSwitchDefault(SwitchDefault node) {
+    for (Label label in node.labels) {
+      SimpleIdentifier labelName = label.label;
+      LabelElementImpl element = new LabelElementImpl(labelName, false, true);
+      _currentHolder.addLabel(element);
+      labelName.staticElement = element;
+    }
+    return super.visitSwitchDefault(node);
+  }
+
+  @override
+  Object visitTypeParameter(TypeParameter node) {
+    SimpleIdentifier parameterName = node.name;
+    TypeParameterElementImpl typeParameter =
+        new TypeParameterElementImpl.forNode(parameterName);
+    TypeParameterTypeImpl typeParameterType =
+        new TypeParameterTypeImpl(typeParameter);
+    typeParameter.type = typeParameterType;
+    _currentHolder.addTypeParameter(typeParameter);
+    parameterName.staticElement = typeParameter;
+    return super.visitTypeParameter(node);
+  }
+
+  @override
+  Object visitVariableDeclaration(VariableDeclaration node) {
+    bool isConst = node.isConst;
+    bool isFinal = node.isFinal;
+    bool hasInitializer = node.initializer != null;
+    VariableElementImpl element;
+    if (_inFieldContext) {
+      SimpleIdentifier fieldName = node.name;
+      FieldElementImpl field;
+      if ((isConst || isFinal) && hasInitializer) {
+        field = new ConstFieldElementImpl.forNode(fieldName);
+      } else {
+        field = new FieldElementImpl.forNode(fieldName);
+      }
+      element = field;
+      if ((node.parent as VariableDeclarationList).type == null) {
+        field.hasImplicitType = true;
+      }
+      _currentHolder.addField(field);
+      fieldName.staticElement = field;
+    } else if (_inFunction) {
+      SimpleIdentifier variableName = node.name;
+      LocalVariableElementImpl variable;
+      if (isConst && hasInitializer) {
+        variable = new ConstLocalVariableElementImpl.forNode(variableName);
+      } else {
+        variable = new LocalVariableElementImpl.forNode(variableName);
+      }
+      element = variable;
+      Block enclosingBlock = node.getAncestor((node) => node is Block);
+      // TODO(brianwilkerson) This isn't right for variables declared in a for
+      // loop.
+      variable.setVisibleRange(enclosingBlock.offset, enclosingBlock.length);
+      if ((node.parent as VariableDeclarationList).type == null) {
+        variable.hasImplicitType = true;
+      }
+      _currentHolder.addLocalVariable(variable);
+      variableName.staticElement = element;
+    } else {
+      SimpleIdentifier variableName = node.name;
+      TopLevelVariableElementImpl variable;
+      if (isConst && hasInitializer) {
+        variable = new ConstTopLevelVariableElementImpl(variableName);
+      } else {
+        variable = new TopLevelVariableElementImpl.forNode(variableName);
+      }
+      element = variable;
+      if ((node.parent as VariableDeclarationList).type == null) {
+        variable.hasImplicitType = true;
+      }
+      _currentHolder.addTopLevelVariable(variable);
+      variableName.staticElement = element;
+    }
+    element.const3 = isConst;
+    element.final2 = isFinal;
+    if (hasInitializer) {
+      ElementHolder holder = new ElementHolder();
+      bool wasInFieldContext = _inFieldContext;
+      _inFieldContext = false;
+      try {
+        _visit(holder, node.initializer);
+      } finally {
+        _inFieldContext = wasInFieldContext;
+      }
+      FunctionElementImpl initializer =
+          new FunctionElementImpl.forOffset(node.initializer.beginToken.offset);
+      initializer.functions = holder.functions;
+      initializer.labels = holder.labels;
+      initializer.localVariables = holder.localVariables;
+      initializer.synthetic = true;
+      element.initializer = initializer;
+      holder.validate();
+    }
+    if (element is PropertyInducingElementImpl) {
+      if (_inFieldContext) {
+        (element as FieldElementImpl).static =
+            (node.parent.parent as FieldDeclaration).isStatic;
+      }
+      PropertyAccessorElementImpl getter =
+          new PropertyAccessorElementImpl.forVariable(element);
+      getter.getter = true;
+      if (element.hasImplicitType) {
+        getter.hasImplicitReturnType = true;
+      }
+      _currentHolder.addAccessor(getter);
+      element.getter = getter;
+      if (!isConst && !isFinal) {
+        PropertyAccessorElementImpl setter =
+            new PropertyAccessorElementImpl.forVariable(element);
+        setter.setter = true;
+        ParameterElementImpl parameter =
+            new ParameterElementImpl("_${element.name}", element.nameOffset);
+        parameter.synthetic = true;
+        parameter.parameterKind = ParameterKind.REQUIRED;
+        setter.parameters = <ParameterElement>[parameter];
+        _currentHolder.addAccessor(setter);
+        element.setter = setter;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Build the table mapping field names to field elements for the fields defined in the current
+   * class.
+   *
+   * @param fields the field elements defined in the current class
+   */
+  void _buildFieldMap(List<FieldElement> fields) {
+    _fieldMap = new HashMap<String, FieldElement>();
+    int count = fields.length;
+    for (int i = 0; i < count; i++) {
+      FieldElement field = fields[i];
+      _fieldMap[field.name] = field;
+    }
+  }
+
+  /**
+   * Creates the [ConstructorElement]s array with the single default constructor element.
+   *
+   * @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.forNode(null);
+    constructor.synthetic = true;
+    constructor.returnType = interfaceType;
+    FunctionTypeImpl type = new FunctionTypeImpl(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
+   * parameter, and return an array of types corresponding to the given parameters.
+   *
+   * @param typeParameters the type parameters for which types are to be created
+   * @return an array of types corresponding to the given parameters
+   */
+  List<DartType> _createTypeParameterTypes(
+      List<TypeParameterElement> typeParameters) {
+    int typeParameterCount = typeParameters.length;
+    List<DartType> typeArguments = new List<DartType>(typeParameterCount);
+    for (int i = 0; i < typeParameterCount; i++) {
+      TypeParameterElementImpl typeParameter =
+          typeParameters[i] as TypeParameterElementImpl;
+      TypeParameterTypeImpl typeParameterType =
+          new TypeParameterTypeImpl(typeParameter);
+      typeParameter.type = typeParameterType;
+      typeArguments[i] = typeParameterType;
+    }
+    return typeArguments;
+  }
+
+  /**
+   * Return the body of the function that contains the given parameter, or `null` if no
+   * function body could be found.
+   *
+   * @param node the parameter contained in the function whose body is to be returned
+   * @return the body of the function that contains the given parameter
+   */
+  FunctionBody _getFunctionBody(FormalParameter node) {
+    AstNode parent = node.parent;
+    while (parent != null) {
+      if (parent is ConstructorDeclaration) {
+        return parent.body;
+      } else if (parent is FunctionExpression) {
+        return parent.body;
+      } else if (parent is MethodDeclaration) {
+        return parent.body;
+      }
+      parent = parent.parent;
+    }
+    return null;
+  }
+
+  /**
+   * Sets the visible source range for formal parameter.
+   */
+  void _setParameterVisibleRange(
+      FormalParameter node, ParameterElementImpl element) {
+    FunctionBody body = _getFunctionBody(node);
+    if (body != null) {
+      element.setVisibleRange(body.offset, body.length);
+    }
+  }
+
+  /**
+   * Make the given holder be the current holder while visiting the given node.
+   *
+   * @param holder the holder that will gather elements that are built while visiting the children
+   * @param node the node to be visited
+   */
+  void _visit(ElementHolder holder, AstNode node) {
+    if (node != null) {
+      ElementHolder previousHolder = _currentHolder;
+      _currentHolder = holder;
+      try {
+        node.accept(this);
+      } finally {
+        _currentHolder = previousHolder;
+      }
+    }
+  }
+
+  /**
+   * Make the given holder be the current holder while visiting the children of the given node.
+   *
+   * @param holder the holder that will gather elements that are built while visiting the children
+   * @param node the node whose children are to be visited
+   */
+  void _visitChildren(ElementHolder holder, AstNode node) {
+    if (node != null) {
+      ElementHolder previousHolder = _currentHolder;
+      _currentHolder = holder;
+      try {
+        node.visitChildren(this);
+      } finally {
+        _currentHolder = previousHolder;
+      }
+    }
+  }
+}
+
+/**
+ * Instances of the class `ElementHolder` hold on to elements created while traversing an AST
+ * structure so that they can be accessed when creating their enclosing element.
+ */
+class ElementHolder {
+  List<PropertyAccessorElement> _accessors;
+
+  List<ConstructorElement> _constructors;
+
+  List<ClassElement> _enums;
+
+  List<FieldElement> _fields;
+
+  List<FunctionElement> _functions;
+
+  List<LabelElement> _labels;
+
+  List<LocalVariableElement> _localVariables;
+
+  List<MethodElement> _methods;
+
+  List<ParameterElement> _parameters;
+
+  List<TopLevelVariableElement> _topLevelVariables;
+
+  List<ClassElement> _types;
+
+  List<FunctionTypeAliasElement> _typeAliases;
+
+  List<TypeParameterElement> _typeParameters;
+
+  List<PropertyAccessorElement> get accessors {
+    if (_accessors == null) {
+      return PropertyAccessorElement.EMPTY_LIST;
+    }
+    List<PropertyAccessorElement> result = _accessors;
+    _accessors = null;
+    return result;
+  }
+
+  List<ConstructorElement> get constructors {
+    if (_constructors == null) {
+      return ConstructorElement.EMPTY_LIST;
+    }
+    List<ConstructorElement> result = _constructors;
+    _constructors = null;
+    return result;
+  }
+
+  List<ClassElement> get enums {
+    if (_enums == null) {
+      return ClassElement.EMPTY_LIST;
+    }
+    List<ClassElement> result = _enums;
+    _enums = null;
+    return result;
+  }
+
+  List<FieldElement> get fields {
+    if (_fields == null) {
+      return FieldElement.EMPTY_LIST;
+    }
+    List<FieldElement> result = _fields;
+    _fields = null;
+    return result;
+  }
+
+  List<FieldElement> get fieldsWithoutFlushing {
+    if (_fields == null) {
+      return FieldElement.EMPTY_LIST;
+    }
+    List<FieldElement> result = _fields;
+    return result;
+  }
+
+  List<FunctionElement> get functions {
+    if (_functions == null) {
+      return FunctionElement.EMPTY_LIST;
+    }
+    List<FunctionElement> result = _functions;
+    _functions = null;
+    return result;
+  }
+
+  List<LabelElement> get labels {
+    if (_labels == null) {
+      return LabelElement.EMPTY_LIST;
+    }
+    List<LabelElement> result = _labels;
+    _labels = null;
+    return result;
+  }
+
+  List<LocalVariableElement> get localVariables {
+    if (_localVariables == null) {
+      return LocalVariableElement.EMPTY_LIST;
+    }
+    List<LocalVariableElement> result = _localVariables;
+    _localVariables = null;
+    return result;
+  }
+
+  List<MethodElement> get methods {
+    if (_methods == null) {
+      return MethodElement.EMPTY_LIST;
+    }
+    List<MethodElement> result = _methods;
+    _methods = null;
+    return result;
+  }
+
+  List<ParameterElement> get parameters {
+    if (_parameters == null) {
+      return ParameterElement.EMPTY_LIST;
+    }
+    List<ParameterElement> result = _parameters;
+    _parameters = null;
+    return result;
+  }
+
+  List<TopLevelVariableElement> get topLevelVariables {
+    if (_topLevelVariables == null) {
+      return TopLevelVariableElement.EMPTY_LIST;
+    }
+    List<TopLevelVariableElement> result = _topLevelVariables;
+    _topLevelVariables = null;
+    return result;
+  }
+
+  List<FunctionTypeAliasElement> get typeAliases {
+    if (_typeAliases == null) {
+      return FunctionTypeAliasElement.EMPTY_LIST;
+    }
+    List<FunctionTypeAliasElement> result = _typeAliases;
+    _typeAliases = null;
+    return result;
+  }
+
+  List<TypeParameterElement> get typeParameters {
+    if (_typeParameters == null) {
+      return TypeParameterElement.EMPTY_LIST;
+    }
+    List<TypeParameterElement> result = _typeParameters;
+    _typeParameters = null;
+    return result;
+  }
+
+  List<ClassElement> get types {
+    if (_types == null) {
+      return ClassElement.EMPTY_LIST;
+    }
+    List<ClassElement> result = _types;
+    _types = null;
+    return result;
+  }
+
+  void addAccessor(PropertyAccessorElement element) {
+    if (_accessors == null) {
+      _accessors = new List<PropertyAccessorElement>();
+    }
+    _accessors.add(element);
+  }
+
+  void addConstructor(ConstructorElement element) {
+    if (_constructors == null) {
+      _constructors = new List<ConstructorElement>();
+    }
+    _constructors.add(element);
+  }
+
+  void addEnum(ClassElement element) {
+    if (_enums == null) {
+      _enums = new List<ClassElement>();
+    }
+    _enums.add(element);
+  }
+
+  void addField(FieldElement element) {
+    if (_fields == null) {
+      _fields = new List<FieldElement>();
+    }
+    _fields.add(element);
+  }
+
+  void addFunction(FunctionElement element) {
+    if (_functions == null) {
+      _functions = new List<FunctionElement>();
+    }
+    _functions.add(element);
+  }
+
+  void addLabel(LabelElement element) {
+    if (_labels == null) {
+      _labels = new List<LabelElement>();
+    }
+    _labels.add(element);
+  }
+
+  void addLocalVariable(LocalVariableElement element) {
+    if (_localVariables == null) {
+      _localVariables = new List<LocalVariableElement>();
+    }
+    _localVariables.add(element);
+  }
+
+  void addMethod(MethodElement element) {
+    if (_methods == null) {
+      _methods = new List<MethodElement>();
+    }
+    _methods.add(element);
+  }
+
+  void addParameter(ParameterElement element) {
+    if (_parameters == null) {
+      _parameters = new List<ParameterElement>();
+    }
+    _parameters.add(element);
+  }
+
+  void addTopLevelVariable(TopLevelVariableElement element) {
+    if (_topLevelVariables == null) {
+      _topLevelVariables = new List<TopLevelVariableElement>();
+    }
+    _topLevelVariables.add(element);
+  }
+
+  void addType(ClassElement element) {
+    if (_types == null) {
+      _types = new List<ClassElement>();
+    }
+    _types.add(element);
+  }
+
+  void addTypeAlias(FunctionTypeAliasElement element) {
+    if (_typeAliases == null) {
+      _typeAliases = new List<FunctionTypeAliasElement>();
+    }
+    _typeAliases.add(element);
+  }
+
+  void addTypeParameter(TypeParameterElement element) {
+    if (_typeParameters == null) {
+      _typeParameters = new List<TypeParameterElement>();
+    }
+    _typeParameters.add(element);
+  }
+
+  FieldElement getField(String fieldName) {
+    if (_fields == null) {
+      return null;
+    }
+    for (FieldElement field in _fields) {
+      if (field.name == fieldName) {
+        return field;
+      }
+    }
+    return null;
+  }
+
+  TopLevelVariableElement getTopLevelVariable(String variableName) {
+    if (_topLevelVariables == null) {
+      return null;
+    }
+    for (TopLevelVariableElement variable in _topLevelVariables) {
+      if (variable.name == variableName) {
+        return variable;
+      }
+    }
+    return null;
+  }
+
+  void validate() {
+    StringBuffer buffer = new StringBuffer();
+    if (_accessors != null) {
+      buffer.write(_accessors.length);
+      buffer.write(" accessors");
+    }
+    if (_constructors != null) {
+      if (buffer.length > 0) {
+        buffer.write("; ");
+      }
+      buffer.write(_constructors.length);
+      buffer.write(" constructors");
+    }
+    if (_fields != null) {
+      if (buffer.length > 0) {
+        buffer.write("; ");
+      }
+      buffer.write(_fields.length);
+      buffer.write(" fields");
+    }
+    if (_functions != null) {
+      if (buffer.length > 0) {
+        buffer.write("; ");
+      }
+      buffer.write(_functions.length);
+      buffer.write(" functions");
+    }
+    if (_labels != null) {
+      if (buffer.length > 0) {
+        buffer.write("; ");
+      }
+      buffer.write(_labels.length);
+      buffer.write(" labels");
+    }
+    if (_localVariables != null) {
+      if (buffer.length > 0) {
+        buffer.write("; ");
+      }
+      buffer.write(_localVariables.length);
+      buffer.write(" local variables");
+    }
+    if (_methods != null) {
+      if (buffer.length > 0) {
+        buffer.write("; ");
+      }
+      buffer.write(_methods.length);
+      buffer.write(" methods");
+    }
+    if (_parameters != null) {
+      if (buffer.length > 0) {
+        buffer.write("; ");
+      }
+      buffer.write(_parameters.length);
+      buffer.write(" parameters");
+    }
+    if (_topLevelVariables != null) {
+      if (buffer.length > 0) {
+        buffer.write("; ");
+      }
+      buffer.write(_topLevelVariables.length);
+      buffer.write(" top-level variables");
+    }
+    if (_types != null) {
+      if (buffer.length > 0) {
+        buffer.write("; ");
+      }
+      buffer.write(_types.length);
+      buffer.write(" types");
+    }
+    if (_typeAliases != null) {
+      if (buffer.length > 0) {
+        buffer.write("; ");
+      }
+      buffer.write(_typeAliases.length);
+      buffer.write(" type aliases");
+    }
+    if (_typeParameters != null) {
+      if (buffer.length > 0) {
+        buffer.write("; ");
+      }
+      buffer.write(_typeParameters.length);
+      buffer.write(" type parameters");
+    }
+    if (buffer.length > 0) {
+      AnalysisEngine.instance.logger
+          .logError("Failed to capture elements: $buffer");
+    }
+  }
+}
+
+/**
+ * Instances of the class `EnclosedScope` implement a scope that is lexically enclosed in
+ * another scope.
+ */
+class EnclosedScope extends Scope {
+  /**
+   * The scope in which this scope is lexically enclosed.
+   */
+  final Scope enclosingScope;
+
+  /**
+   * A table mapping names that will be defined in this scope, but right now are not initialized.
+   * According to the scoping rules these names are hidden, even if they were defined in an outer
+   * scope.
+   */
+  HashMap<String, Element> _hiddenElements = new HashMap<String, Element>();
+
+  /**
+   * A flag indicating whether there are any names defined in this scope.
+   */
+  bool _hasHiddenName = false;
+
+  /**
+   * Initialize a newly created scope enclosed within another scope.
+   *
+   * @param enclosingScope the scope in which this scope is lexically enclosed
+   */
+  EnclosedScope(this.enclosingScope);
+
+  @override
+  AnalysisErrorListener get errorListener => enclosingScope.errorListener;
+
+  /**
+   * Record that given element is declared in this scope, but hasn't been initialized yet, so it is
+   * error to use. If there is already an element with the given name defined in an outer scope,
+   * then it will become unavailable.
+   *
+   * @param element the element declared, but not initialized in this scope
+   */
+  void hide(Element element) {
+    if (element != null) {
+      String name = element.name;
+      if (name != null && !name.isEmpty) {
+        _hiddenElements[name] = element;
+        _hasHiddenName = true;
+      }
+    }
+  }
+
+  @override
+  Element internalLookup(
+      Identifier identifier, String name, LibraryElement referencingLibrary) {
+    Element element = localLookup(name, referencingLibrary);
+    if (element != null) {
+      return element;
+    }
+    // May be there is a hidden Element.
+    if (_hasHiddenName) {
+      Element hiddenElement = _hiddenElements[name];
+      if (hiddenElement != null) {
+        errorListener.onError(new AnalysisError(
+            getSource(identifier),
+            identifier.offset,
+            identifier.length,
+            CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION, []));
+        return hiddenElement;
+      }
+    }
+    // Check enclosing scope.
+    return enclosingScope.internalLookup(identifier, name, referencingLibrary);
+  }
+}
+
+/**
+ * Instances of the class `EnumMemberBuilder` build the members in enum declarations.
+ */
+class EnumMemberBuilder extends RecursiveAstVisitor<Object> {
+  /**
+   * The type provider used to access the types needed to build an element model for enum
+   * declarations.
+   */
+  final TypeProvider _typeProvider;
+
+  /**
+   * Initialize a newly created enum member builder.
+   *
+   * @param typeProvider the type provider used to access the types needed to build an element model
+   *          for enum declarations
+   */
+  EnumMemberBuilder(this._typeProvider);
+
+  @override
+  Object visitEnumDeclaration(EnumDeclaration node) {
+    //
+    // Finish building the enum.
+    //
+    ClassElementImpl enumElement = node.name.staticElement as ClassElementImpl;
+    InterfaceType enumType = enumElement.type;
+    enumElement.supertype = _typeProvider.objectType;
+    //
+    // Populate the fields.
+    //
+    List<FieldElement> fields = new List<FieldElement>();
+    List<PropertyAccessorElement> getters = new List<PropertyAccessorElement>();
+    InterfaceType intType = _typeProvider.intType;
+    String indexFieldName = "index";
+    FieldElementImpl indexField = new FieldElementImpl(indexFieldName, -1);
+    indexField.final2 = true;
+    indexField.synthetic = true;
+    indexField.type = intType;
+    fields.add(indexField);
+    getters.add(_createGetter(indexField));
+    ConstFieldElementImpl valuesField = new ConstFieldElementImpl("values", -1);
+    valuesField.static = true;
+    valuesField.const3 = true;
+    valuesField.synthetic = true;
+    valuesField.type = _typeProvider.listType.substitute4(<DartType>[enumType]);
+    fields.add(valuesField);
+    getters.add(_createGetter(valuesField));
+    //
+    // Build the enum constants.
+    //
+    NodeList<EnumConstantDeclaration> constants = node.constants;
+    List<DartObjectImpl> constantValues = new List<DartObjectImpl>();
+    int constantCount = constants.length;
+    for (int i = 0; i < constantCount; i++) {
+      SimpleIdentifier constantName = constants[i].name;
+      FieldElementImpl constantField =
+          new ConstFieldElementImpl.forNode(constantName);
+      constantField.static = true;
+      constantField.const3 = true;
+      constantField.type = enumType;
+      //
+      // Create a value for the constant.
+      //
+      HashMap<String, DartObjectImpl> fieldMap =
+          new HashMap<String, DartObjectImpl>();
+      fieldMap[indexFieldName] = new DartObjectImpl(intType, new IntState(i));
+      DartObjectImpl value =
+          new DartObjectImpl(enumType, new GenericState(fieldMap));
+      constantValues.add(value);
+      constantField.evaluationResult = new EvaluationResultImpl(value);
+      fields.add(constantField);
+      getters.add(_createGetter(constantField));
+      constantName.staticElement = constantField;
+    }
+    //
+    // Build the value of the 'values' field.
+    //
+    valuesField.evaluationResult = new EvaluationResultImpl(
+        new DartObjectImpl(valuesField.type, new ListState(constantValues)));
+    //
+    // Finish building the enum.
+    //
+    enumElement.fields = fields;
+    enumElement.accessors = getters;
+    // Client code isn't allowed to invoke the constructor, so we do not model
+    // it.
+    return super.visitEnumDeclaration(node);
+  }
+
+  /**
+   * Create a getter that corresponds to the given field.
+   *
+   * @param field the field for which a getter is to be created
+   * @return the getter that was created
+   */
+  PropertyAccessorElement _createGetter(FieldElementImpl field) {
+    PropertyAccessorElementImpl getter =
+        new PropertyAccessorElementImpl.forVariable(field);
+    getter.getter = true;
+    getter.returnType = field.type;
+    getter.type = new FunctionTypeImpl(getter);
+    field.getter = getter;
+    return getter;
+  }
+}
+
+/**
+ * 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;
+
+  @override
+  bool visitArgumentList(ArgumentList node) =>
+      _visitExpressions(node.arguments);
+
+  @override
+  bool visitAsExpression(AsExpression node) => _nodeExits(node.expression);
+
+  @override
+  bool visitAssertStatement(AssertStatement node) => _nodeExits(node.condition);
+
+  @override
+  bool visitAssignmentExpression(AssignmentExpression node) =>
+      _nodeExits(node.leftHandSide) || _nodeExits(node.rightHandSide);
+
+  @override
+  bool visitAwaitExpression(AwaitExpression node) =>
+      _nodeExits(node.expression);
+
+  @override
+  bool visitBinaryExpression(BinaryExpression node) {
+    Expression lhsExpression = node.leftOperand;
+    sc.TokenType operatorType = node.operator.type;
+    // If the operator is || and the left hand side is false literal, don't
+    // consider the RHS of the binary expression.
+    // 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 (operatorType == sc.TokenType.BAR_BAR) {
+      if (lhsExpression is BooleanLiteral) {
+        BooleanLiteral booleanLiteral = lhsExpression;
+        if (!booleanLiteral.value) {
+          return false;
+        }
+      }
+    }
+    // If the operator is && and the left hand side is true literal, don't
+    // consider the RHS of the binary expression.
+    if (operatorType == sc.TokenType.AMPERSAND_AMPERSAND) {
+      if (lhsExpression is BooleanLiteral) {
+        BooleanLiteral booleanLiteral = lhsExpression;
+        if (booleanLiteral.value) {
+          return false;
+        }
+      }
+    }
+    Expression rhsExpression = node.rightOperand;
+    return _nodeExits(lhsExpression) || _nodeExits(rhsExpression);
+  }
+
+  @override
+  bool visitBlock(Block node) => _visitStatements(node.statements);
+
+  @override
+  bool visitBlockFunctionBody(BlockFunctionBody node) => _nodeExits(node.block);
+
+  @override
+  bool visitBreakStatement(BreakStatement node) {
+    _enclosingBlockContainsBreak = true;
+    return false;
+  }
+
+  @override
+  bool visitCascadeExpression(CascadeExpression node) =>
+      _nodeExits(node.target) || _visitExpressions(node.cascadeSections);
+
+  @override
+  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 (_nodeExits(conditionExpression)) {
+      return true;
+    }
+    if (thenStatement == null || elseStatement == null) {
+      return false;
+    }
+    return thenStatement.accept(this) && elseStatement.accept(this);
+  }
+
+  @override
+  bool visitContinueStatement(ContinueStatement node) => false;
+
+  @override
+  bool visitDoStatement(DoStatement node) {
+    bool outerBreakValue = _enclosingBlockContainsBreak;
+    _enclosingBlockContainsBreak = false;
+    try {
+      Expression conditionExpression = node.condition;
+      if (_nodeExits(conditionExpression)) {
+        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 = _nodeExits(node.body);
+        if (booleanLiteral.value &&
+            (blockReturns || !_enclosingBlockContainsBreak)) {
+          return true;
+        }
+      }
+      return false;
+    } finally {
+      _enclosingBlockContainsBreak = outerBreakValue;
+    }
+  }
+
+  @override
+  bool visitEmptyStatement(EmptyStatement node) => false;
+
+  @override
+  bool visitExpressionStatement(ExpressionStatement node) =>
+      _nodeExits(node.expression);
+
+  @override
+  bool visitForEachStatement(ForEachStatement node) {
+    bool outerBreakValue = _enclosingBlockContainsBreak;
+    _enclosingBlockContainsBreak = false;
+    try {
+      return _nodeExits(node.iterable);
+    } finally {
+      _enclosingBlockContainsBreak = outerBreakValue;
+    }
+  }
+
+  @override
+  bool visitForStatement(ForStatement node) {
+    bool outerBreakValue = _enclosingBlockContainsBreak;
+    _enclosingBlockContainsBreak = false;
+    try {
+      if (node.variables != null &&
+          _visitVariableDeclarations(node.variables.variables)) {
+        return true;
+      }
+      if (node.initialization != null && _nodeExits(node.initialization)) {
+        return true;
+      }
+      Expression conditionExpression = node.condition;
+      if (conditionExpression != null && _nodeExits(conditionExpression)) {
+        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 = _nodeExits(node.body);
+        if (blockReturns || !_enclosingBlockContainsBreak) {
+          return true;
+        }
+      }
+      return false;
+    } finally {
+      _enclosingBlockContainsBreak = outerBreakValue;
+    }
+  }
+
+  @override
+  bool visitFunctionDeclarationStatement(FunctionDeclarationStatement node) =>
+      false;
+
+  @override
+  bool visitFunctionExpression(FunctionExpression node) => false;
+
+  @override
+  bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
+    if (_nodeExits(node.function)) {
+      return true;
+    }
+    return node.argumentList.accept(this);
+  }
+
+  @override
+  bool visitIdentifier(Identifier node) => false;
+
+  @override
+  bool visitIfStatement(IfStatement node) {
+    Expression conditionExpression = node.condition;
+    Statement thenStatement = node.thenStatement;
+    Statement elseStatement = node.elseStatement;
+    if (_nodeExits(conditionExpression)) {
+      return true;
+    }
+    // TODO(jwren) Do we want to take all constant expressions into account?
+    if (conditionExpression is BooleanLiteral) {
+      BooleanLiteral booleanLiteral = conditionExpression;
+      if (booleanLiteral.value) {
+        // if(true) ...
+        return _nodeExits(thenStatement);
+      } else if (elseStatement != null) {
+        // if (false) ...
+        return _nodeExits(elseStatement);
+      }
+    }
+    if (thenStatement == null || elseStatement == null) {
+      return false;
+    }
+    return _nodeExits(thenStatement) && _nodeExits(elseStatement);
+  }
+
+  @override
+  bool visitIndexExpression(IndexExpression node) {
+    Expression target = node.realTarget;
+    if (_nodeExits(target)) {
+      return true;
+    }
+    if (_nodeExits(node.index)) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  bool visitInstanceCreationExpression(InstanceCreationExpression node) =>
+      _nodeExits(node.argumentList);
+
+  @override
+  bool visitIsExpression(IsExpression node) => node.expression.accept(this);
+
+  @override
+  bool visitLabel(Label node) => false;
+
+  @override
+  bool visitLabeledStatement(LabeledStatement node) =>
+      node.statement.accept(this);
+
+  @override
+  bool visitLiteral(Literal node) => false;
+
+  @override
+  bool visitMethodInvocation(MethodInvocation node) {
+    Expression target = node.realTarget;
+    if (target != null && target.accept(this)) {
+      return true;
+    }
+    return _nodeExits(node.argumentList);
+  }
+
+  @override
+  bool visitNamedExpression(NamedExpression node) =>
+      node.expression.accept(this);
+
+  @override
+  bool visitParenthesizedExpression(ParenthesizedExpression node) =>
+      node.expression.accept(this);
+
+  @override
+  bool visitPostfixExpression(PostfixExpression node) => false;
+
+  @override
+  bool visitPrefixExpression(PrefixExpression node) => false;
+
+  @override
+  bool visitPropertyAccess(PropertyAccess node) {
+    Expression target = node.realTarget;
+    if (target != null && target.accept(this)) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  bool visitRethrowExpression(RethrowExpression node) => true;
+
+  @override
+  bool visitReturnStatement(ReturnStatement node) => true;
+
+  @override
+  bool visitSuperExpression(SuperExpression node) => false;
+
+  @override
+  bool visitSwitchCase(SwitchCase node) => _visitStatements(node.statements);
+
+  @override
+  bool visitSwitchDefault(SwitchDefault node) =>
+      _visitStatements(node.statements);
+
+  @override
+  bool visitSwitchStatement(SwitchStatement node) {
+    bool outerBreakValue = _enclosingBlockContainsBreak;
+    _enclosingBlockContainsBreak = false;
+    try {
+      bool hasDefault = false;
+      List<SwitchMember> members = node.members;
+      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;
+        }
+      }
+      // All of the members exit, determine whether there are possible cases
+      // that are not caught by the members.
+      DartType type = node.expression == null ? null : node.expression.bestType;
+      if (type is InterfaceType) {
+        ClassElement element = type.element;
+        if (element != null && element.isEnum) {
+          // If some of the enum values are not covered, then a warning will
+          // have already been generated, so there's no point in generating a
+          // hint.
+          return true;
+        }
+      }
+      return hasDefault;
+    } finally {
+      _enclosingBlockContainsBreak = outerBreakValue;
+    }
+  }
+
+  @override
+  bool visitThisExpression(ThisExpression node) => false;
+
+  @override
+  bool visitThrowExpression(ThrowExpression node) => true;
+
+  @override
+  bool visitTryStatement(TryStatement node) {
+    if (_nodeExits(node.body)) {
+      return true;
+    }
+    Block finallyBlock = node.finallyBlock;
+    if (_nodeExits(finallyBlock)) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  bool visitTypeName(TypeName node) => false;
+
+  @override
+  bool visitVariableDeclaration(VariableDeclaration node) {
+    Expression initializer = node.initializer;
+    if (initializer != null) {
+      return initializer.accept(this);
+    }
+    return false;
+  }
+
+  @override
+  bool visitVariableDeclarationList(VariableDeclarationList node) =>
+      _visitVariableDeclarations(node.variables);
+
+  @override
+  bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
+    NodeList<VariableDeclaration> variables = node.variables.variables;
+    for (int i = 0; i < variables.length; i++) {
+      if (variables[i].accept(this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @override
+  bool visitWhileStatement(WhileStatement node) {
+    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;
+    }
+  }
+
+  /**
+   * Return `true` if the given node exits.
+   *
+   * @param node the node being tested
+   * @return `true` if the given node exits
+   */
+  bool _nodeExits(AstNode node) {
+    if (node == null) {
+      return false;
+    }
+    return node.accept(this);
+  }
+
+  bool _visitExpressions(NodeList<Expression> expressions) {
+    for (int i = expressions.length - 1; i >= 0; i--) {
+      if (expressions[i].accept(this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool _visitStatements(NodeList<Statement> statements) {
+    for (int i = statements.length - 1; i >= 0; i--) {
+      if (statements[i].accept(this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool _visitVariableDeclarations(
+      NodeList<VariableDeclaration> variableDeclarations) {
+    for (int i = variableDeclarations.length - 1; i >= 0; i--) {
+      if (variableDeclarations[i].accept(this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Return `true` if the given [node] exits.
+   */
+  static bool exits(AstNode node) {
+    return new ExitDetector()._nodeExits(node);
+  }
+}
+
+/**
+ * The scope defined by a function.
+ */
+class FunctionScope extends EnclosedScope {
+  /**
+   * The element representing the function that defines this scope.
+   */
+  final ExecutableElement _functionElement;
+
+  /**
+   * A flag indicating whether the parameters have already been defined, used to
+   * prevent the parameters from being defined multiple times.
+   */
+  bool _parametersDefined = false;
+
+  /**
+   * Initialize a newly created scope enclosed within the [enclosingScope] that
+   * represents the given [_functionElement].
+   */
+  FunctionScope(Scope enclosingScope, this._functionElement)
+      : super(new EnclosedScope(new EnclosedScope(enclosingScope))) {
+    if (_functionElement == null) {
+      throw new IllegalArgumentException("function element cannot be null");
+    }
+    _defineTypeParameters();
+  }
+
+  /**
+   * Define the parameters for the given function in the scope that encloses
+   * this function.
+   */
+  void defineParameters() {
+    if (_parametersDefined) {
+      return;
+    }
+    _parametersDefined = true;
+    Scope parameterScope = enclosingScope;
+    for (ParameterElement parameter in _functionElement.parameters) {
+      if (!parameter.isInitializingFormal) {
+        parameterScope.define(parameter);
+      }
+    }
+  }
+
+  /**
+   * Define the type parameters for the function.
+   */
+  void _defineTypeParameters() {
+    Scope typeParameterScope = enclosingScope.enclosingScope;
+    for (TypeParameterElement typeParameter
+        in _functionElement.typeParameters) {
+      typeParameterScope.define(typeParameter);
+    }
+  }
+}
+
+/**
+ * The scope defined by a function type alias.
+ */
+class FunctionTypeScope extends EnclosedScope {
+  final FunctionTypeAliasElement _typeElement;
+
+  bool _parametersDefined = false;
+
+  /**
+   * Initialize a newly created scope enclosed within the [enclosingScope] that
+   * represents the given [_typeElement].
+   */
+  FunctionTypeScope(Scope enclosingScope, this._typeElement)
+      : super(new EnclosedScope(enclosingScope)) {
+    _defineTypeParameters();
+  }
+
+  /**
+   * Define the parameters for the function type alias.
+   */
+  void defineParameters() {
+    if (_parametersDefined) {
+      return;
+    }
+    _parametersDefined = true;
+    for (ParameterElement parameter in _typeElement.parameters) {
+      define(parameter);
+    }
+  }
+
+  /**
+   * Define the type parameters for the function type alias.
+   */
+  void _defineTypeParameters() {
+    Scope typeParameterScope = enclosingScope;
+    for (TypeParameterElement typeParameter in _typeElement.typeParameters) {
+      typeParameterScope.define(typeParameter);
+    }
+  }
+}
+
+/**
+ * A visitor that visits ASTs and fills [UsedImportedElements].
+ */
+class GatherUsedImportedElementsVisitor extends RecursiveAstVisitor {
+  final LibraryElement library;
+  final UsedImportedElements usedElements = new UsedImportedElements();
+
+  GatherUsedImportedElementsVisitor(this.library);
+
+  @override
+  void visitExportDirective(ExportDirective node) {
+    _visitMetadata(node.metadata);
+  }
+
+  @override
+  void visitImportDirective(ImportDirective node) {
+    _visitMetadata(node.metadata);
+  }
+
+  @override
+  void visitLibraryDirective(LibraryDirective node) {
+    _visitMetadata(node.metadata);
+  }
+
+  @override
+  void visitPrefixedIdentifier(PrefixedIdentifier node) {
+    // If the prefixed identifier references some A.B, where A is a library
+    // prefix, then we can lookup the associated ImportDirective in
+    // prefixElementMap and remove it from the unusedImports list.
+    SimpleIdentifier prefixIdentifier = node.prefix;
+    Element element = prefixIdentifier.staticElement;
+    if (element is PrefixElement) {
+      usedElements.prefixes.add(element);
+      return;
+    }
+    // Otherwise, pass the prefixed identifier element and name onto
+    // visitIdentifier.
+    _visitIdentifier(element, prefixIdentifier.name);
+  }
+
+  @override
+  void visitSimpleIdentifier(SimpleIdentifier node) {
+    _visitIdentifier(node.staticElement, node.name);
+  }
+
+  void _visitIdentifier(Element element, String name) {
+    if (element == null) {
+      return;
+    }
+    // If the element is multiply defined then call this method recursively for
+    // each of the conflicting elements.
+    if (element is MultiplyDefinedElement) {
+      MultiplyDefinedElement multiplyDefinedElement = element;
+      for (Element elt in multiplyDefinedElement.conflictingElements) {
+        _visitIdentifier(elt, name);
+      }
+      return;
+    } else if (element is PrefixElement) {
+      usedElements.prefixes.add(element);
+      return;
+    } else if (element.enclosingElement is! CompilationUnitElement) {
+      // Identifiers that aren't a prefix element and whose enclosing element
+      // isn't a CompilationUnit are ignored- this covers the case the
+      // identifier is a relative-reference, a reference to an identifier not
+      // imported by this library.
+      return;
+    }
+    // Ignore if an unknown library.
+    LibraryElement containingLibrary = element.library;
+    if (containingLibrary == null) {
+      return;
+    }
+    // Ignore if a local element.
+    if (library == containingLibrary) {
+      return;
+    }
+    // Remember the element.
+    usedElements.elements.add(element);
+  }
+
+  /**
+   * Given some [NodeList] of [Annotation]s, ensure that the identifiers are visited by
+   * this visitor. Specifically, this covers the cases where AST nodes don't have their identifiers
+   * visited by this visitor, but still need their annotations visited.
+   *
+   * @param annotations the list of annotations to visit
+   */
+  void _visitMetadata(NodeList<Annotation> annotations) {
+    int count = annotations.length;
+    for (int i = 0; i < count; i++) {
+      annotations[i].accept(this);
+    }
+  }
+}
+
+/**
+ * An [AstVisitor] that fills [UsedLocalElements].
+ */
+class GatherUsedLocalElementsVisitor extends RecursiveAstVisitor {
+  final UsedLocalElements usedElements = new UsedLocalElements();
+
+  final LibraryElement _enclosingLibrary;
+  ClassElement _enclosingClass;
+  ExecutableElement _enclosingExec;
+
+  GatherUsedLocalElementsVisitor(this._enclosingLibrary);
+
+  @override
+  visitCatchClause(CatchClause node) {
+    SimpleIdentifier exceptionParameter = node.exceptionParameter;
+    SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
+    if (exceptionParameter != null) {
+      Element element = exceptionParameter.staticElement;
+      usedElements.addCatchException(element);
+      if (stackTraceParameter != null || node.onKeyword == null) {
+        usedElements.addElement(element);
+      }
+    }
+    if (stackTraceParameter != null) {
+      Element element = stackTraceParameter.staticElement;
+      usedElements.addCatchStackTrace(element);
+    }
+    super.visitCatchClause(node);
+  }
+
+  @override
+  visitClassDeclaration(ClassDeclaration node) {
+    ClassElement enclosingClassOld = _enclosingClass;
+    try {
+      _enclosingClass = node.element;
+      super.visitClassDeclaration(node);
+    } finally {
+      _enclosingClass = enclosingClassOld;
+    }
+  }
+
+  @override
+  visitFunctionDeclaration(FunctionDeclaration node) {
+    ExecutableElement enclosingExecOld = _enclosingExec;
+    try {
+      _enclosingExec = node.element;
+      super.visitFunctionDeclaration(node);
+    } finally {
+      _enclosingExec = enclosingExecOld;
+    }
+  }
+
+  @override
+  visitFunctionExpression(FunctionExpression node) {
+    if (node.parent is! FunctionDeclaration) {
+      usedElements.addElement(node.element);
+    }
+    super.visitFunctionExpression(node);
+  }
+
+  @override
+  visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement enclosingExecOld = _enclosingExec;
+    try {
+      _enclosingExec = node.element;
+      super.visitMethodDeclaration(node);
+    } finally {
+      _enclosingExec = enclosingExecOld;
+    }
+  }
+
+  @override
+  visitSimpleIdentifier(SimpleIdentifier node) {
+    if (node.inDeclarationContext()) {
+      return;
+    }
+    Element element = node.staticElement;
+    bool isIdentifierRead = _isReadIdentifier(node);
+    if (element is LocalVariableElement) {
+      if (isIdentifierRead) {
+        usedElements.addElement(element);
+      }
+    } else {
+      _useIdentifierElement(node);
+      if (element == null ||
+          element.enclosingElement is ClassElement &&
+              !identical(element, _enclosingExec)) {
+        usedElements.members.add(node.name);
+        if (isIdentifierRead) {
+          usedElements.readMembers.add(node.name);
+        }
+      }
+    }
+  }
+
+  /**
+   * Marks an [Element] of [node] as used in the library.
+   */
+  void _useIdentifierElement(Identifier node) {
+    Element element = node.staticElement;
+    if (element == null) {
+      return;
+    }
+    // check if a local element
+    if (!identical(element.library, _enclosingLibrary)) {
+      return;
+    }
+    // ignore references to an element from itself
+    if (identical(element, _enclosingClass)) {
+      return;
+    }
+    if (identical(element, _enclosingExec)) {
+      return;
+    }
+    // ignore places where the element is not actually used
+    if (node.parent is TypeName) {
+      if (element is ClassElement) {
+        AstNode parent2 = node.parent.parent;
+        if (parent2 is IsExpression) {
+          return;
+        }
+        if (parent2 is VariableDeclarationList) {
+          return;
+        }
+      }
+    }
+    // OK
+    usedElements.addElement(element);
+  }
+
+  static bool _isReadIdentifier(SimpleIdentifier node) {
+    // not reading at all
+    if (!node.inGetterContext()) {
+      return false;
+    }
+    // check if useless reading
+    AstNode parent = node.parent;
+    if (parent.parent is ExpressionStatement &&
+        (parent is PrefixExpression ||
+            parent is PostfixExpression ||
+            parent is AssignmentExpression && parent.leftHandSide == node)) {
+      // v++;
+      // ++v;
+      // v += 2;
+      return false;
+    }
+    // OK
+    return true;
+  }
+}
+
+/**
+ * Instances of the class `HintGenerator` traverse a library's worth of dart code at a time to
+ * generate hints over the set of sources.
+ *
+ * See [HintCode].
+ */
+class HintGenerator {
+  final List<CompilationUnit> _compilationUnits;
+
+  final InternalAnalysisContext _context;
+
+  final AnalysisErrorListener _errorListener;
+
+  LibraryElement _library;
+
+  GatherUsedImportedElementsVisitor _usedImportedElementsVisitor;
+
+  bool _enableDart2JSHints = false;
+
+  /**
+   * The inheritance manager used to find overridden methods.
+   */
+  InheritanceManager _manager;
+
+  GatherUsedLocalElementsVisitor _usedLocalElementsVisitor;
+
+  HintGenerator(this._compilationUnits, this._context, this._errorListener) {
+    _library = _compilationUnits[0].element.library;
+    _usedImportedElementsVisitor =
+        new GatherUsedImportedElementsVisitor(_library);
+    _enableDart2JSHints = _context.analysisOptions.dart2jsHint;
+    _manager = new InheritanceManager(_compilationUnits[0].element.library);
+    _usedLocalElementsVisitor = new GatherUsedLocalElementsVisitor(_library);
+  }
+
+  void generateForLibrary() {
+    PerformanceStatistics.hints.makeCurrentWhile(() {
+      for (CompilationUnit unit in _compilationUnits) {
+        CompilationUnitElement element = unit.element;
+        if (element != null) {
+          _generateForCompilationUnit(unit, element.source);
+        }
+      }
+      CompilationUnit definingUnit = _compilationUnits[0];
+      ErrorReporter definingUnitErrorReporter =
+          new ErrorReporter(_errorListener, definingUnit.element.source);
+      {
+        ImportsVerifier importsVerifier = new ImportsVerifier();
+        importsVerifier.addImports(definingUnit);
+        importsVerifier
+            .removeUsedElements(_usedImportedElementsVisitor.usedElements);
+        importsVerifier.generateDuplicateImportHints(definingUnitErrorReporter);
+        importsVerifier.generateUnusedImportHints(definingUnitErrorReporter);
+      }
+      _library.accept(new UnusedLocalElementsVerifier(
+          _errorListener, _usedLocalElementsVisitor.usedElements));
+    });
+  }
+
+  void _generateForCompilationUnit(CompilationUnit unit, Source source) {
+    ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
+    unit.accept(_usedImportedElementsVisitor);
+    // dead code analysis
+    unit.accept(new DeadCodeVerifier(errorReporter));
+    unit.accept(_usedLocalElementsVisitor);
+    // dart2js analysis
+    if (_enableDart2JSHints) {
+      unit.accept(new Dart2JSVerifier(errorReporter));
+    }
+    // Dart best practices
+    unit.accept(
+        new BestPracticesVerifier(errorReporter, _context.typeProvider));
+    unit.accept(new OverrideVerifier(errorReporter, _manager));
+    // Find to-do comments
+    new ToDoFinder(errorReporter).findIn(unit);
+    // pub analysis
+    // TODO(danrubel/jwren) Commented out until bugs in the pub verifier are
+    // fixed
+    //    unit.accept(new PubVerifier(context, errorReporter));
+  }
+}
+
+/**
+ * Instances of the class {@code HtmlTagInfo} record information about the tags used in an HTML
+ * file.
+ */
+class HtmlTagInfo {
+  /**
+   * An array containing all of the tags used in the HTML file.
+   */
+  List<String> allTags;
+
+  /**
+   * A table mapping the id's defined in the HTML file to an array containing the names of tags with
+   * that identifier.
+   */
+  HashMap<String, String> idToTagMap;
+
+  /**
+   * A table mapping the classes defined in the HTML file to an array containing the names of tags
+   * with that class.
+   */
+  HashMap<String, List<String>> classToTagsMap;
+
+  /**
+   * Initialize a newly created information holder to hold the given information about the tags in
+   * an HTML file.
+   *
+   * @param allTags an array containing all of the tags used in the HTML file
+   * @param idToTagMap a table mapping the id's defined in the HTML file to an array containing the
+   *          names of tags with that identifier
+   * @param classToTagsMap a table mapping the classes defined in the HTML file to an array
+   *          containing the names of tags with that class
+   */
+  HtmlTagInfo(this.allTags, this.idToTagMap, this.classToTagsMap);
+
+  /**
+   * Return an array containing the tags that have the given class, or {@code null} if there are no
+   * such tags.
+   *
+   * @return an array containing the tags that have the given class
+   */
+  List<String> getTagsWithClass(String identifier) {
+    return classToTagsMap[identifier];
+  }
+
+  /**
+   * Return the tag that has the given identifier, or {@code null} if there is no such tag (the
+   * identifier is not defined).
+   *
+   * @return the tag that has the given identifier
+   */
+  String getTagWithId(String identifier) {
+    return idToTagMap[identifier];
+  }
+}
+
+/**
+ * Instances of the class {@code HtmlTagInfoBuilder} gather information about the tags used in one
+ * or more HTML structures.
+ */
+class HtmlTagInfoBuilder implements ht.XmlVisitor {
+  /**
+   * The name of the 'id' attribute.
+   */
+  static final String ID_ATTRIBUTE = "id";
+
+  /**
+   * The name of the 'class' attribute.
+   */
+  static final String ID_CLASS = "class";
+
+  /**
+   * A set containing all of the tag names used in the HTML.
+   */
+  HashSet<String> tagSet = new HashSet<String>();
+
+  /**
+   * A table mapping the id's that are defined to the tag name with that id.
+   */
+  HashMap<String, String> idMap = new HashMap<String, String>();
+
+  /**
+   * A table mapping the classes that are defined to a set of the tag names with that class.
+   */
+  HashMap<String, HashSet<String>> classMap =
+      new HashMap<String, HashSet<String>>();
+
+  /**
+   * Initialize a newly created HTML tag info builder.
+   */
+  HtmlTagInfoBuilder();
+
+  /**
+   * Create a tag information holder holding all of the information gathered about the tags in the
+   * HTML structures that were visited.
+   *
+   * @return the information gathered about the tags in the visited HTML structures
+   */
+  HtmlTagInfo getTagInfo() {
+    List<String> allTags = tagSet.toList();
+    HashMap<String, List<String>> classToTagsMap =
+        new HashMap<String, List<String>>();
+    classMap.forEach((String key, Set<String> tags) {
+      classToTagsMap[key] = tags.toList();
+    });
+    return new HtmlTagInfo(allTags, idMap, classToTagsMap);
+  }
+
+  @override
+  visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
+    visitXmlTagNode(node);
+  }
+
+  @override
+  visitHtmlUnit(ht.HtmlUnit node) {
+    node.visitChildren(this);
+  }
+
+  @override
+  visitXmlAttributeNode(ht.XmlAttributeNode node) {}
+
+  @override
+  visitXmlTagNode(ht.XmlTagNode node) {
+    node.visitChildren(this);
+    String tagName = node.tag;
+    tagSet.add(tagName);
+    for (ht.XmlAttributeNode attribute in node.attributes) {
+      String attributeName = attribute.name;
+      if (attributeName == ID_ATTRIBUTE) {
+        String attributeValue = attribute.text;
+        if (attributeValue != null) {
+          String tag = idMap[attributeValue];
+          if (tag == null) {
+            idMap[attributeValue] = tagName;
+          } else {
+//            reportError(HtmlWarningCode.MULTIPLY_DEFINED_ID, valueToken);
+          }
+        }
+      } else if (attributeName == ID_CLASS) {
+        String attributeValue = attribute.text;
+        if (attributeValue != null) {
+          HashSet<String> tagList = classMap[attributeValue];
+          if (tagList == null) {
+            tagList = new HashSet<String>();
+            classMap[attributeValue] = tagList;
+          } else {
+//            reportError(HtmlWarningCode.MULTIPLY_DEFINED_ID, valueToken);
+          }
+          tagList.add(tagName);
+        }
+      }
+    }
+  }
+
+//  /**
+//   * Report an error with the given error code at the given location. Use the given arguments to
+//   * compose the error message.
+//   *
+//   * @param errorCode the error code of the error to be reported
+//   * @param offset the offset of the first character to be highlighted
+//   * @param length the number of characters to be highlighted
+//   * @param arguments the arguments used to compose the error message
+//   */
+//  private void reportError(ErrorCode errorCode, Token token, Object... arguments) {
+//    errorListener.onError(new AnalysisError(
+//        htmlElement.getSource(),
+//        token.getOffset(),
+//        token.getLength(),
+//        errorCode,
+//        arguments));
+//  }
+//
+//  /**
+//   * Report an error with the given error code at the given location. Use the given arguments to
+//   * compose the error message.
+//   *
+//   * @param errorCode the error code of the error to be reported
+//   * @param offset the offset of the first character to be highlighted
+//   * @param length the number of characters to be highlighted
+//   * @param arguments the arguments used to compose the error message
+//   */
+//  private void reportError(ErrorCode errorCode, int offset, int length, Object... arguments) {
+//    errorListener.onError(new AnalysisError(
+//        htmlElement.getSource(),
+//        offset,
+//        length,
+//        errorCode,
+//        arguments));
+//  }
+}
+
+/**
+ * Instances of the class `HtmlUnitBuilder` build an element model for a single HTML unit.
+ */
+class HtmlUnitBuilder implements ht.XmlVisitor<Object> {
+  static String _SRC = "src";
+
+  /**
+   * The analysis context in which the element model will be built.
+   */
+  final InternalAnalysisContext _context;
+
+  /**
+   * The error listener to which errors will be reported.
+   */
+  RecordingErrorListener _errorListener;
+
+  /**
+   * The HTML element being built.
+   */
+  HtmlElementImpl _htmlElement;
+
+  /**
+   * The elements in the path from the HTML unit to the current tag node.
+   */
+  List<ht.XmlTagNode> _parentNodes;
+
+  /**
+   * The script elements being built.
+   */
+  List<HtmlScriptElement> _scripts;
+
+  /**
+   * A set of the libraries that were resolved while resolving the HTML unit.
+   */
+  Set<Library> _resolvedLibraries = new HashSet<Library>();
+
+  /**
+   * Initialize a newly created HTML unit builder.
+   *
+   * @param context the analysis context in which the element model will be built
+   */
+  HtmlUnitBuilder(this._context) {
+    this._errorListener = new RecordingErrorListener();
+  }
+
+  /**
+   * Return the listener to which analysis errors will be reported.
+   *
+   * @return the listener to which analysis errors will be reported
+   */
+  RecordingErrorListener get errorListener => _errorListener;
+
+  /**
+   * Return an array containing information about all of the libraries that were resolved.
+   *
+   * @return an array containing the libraries that were resolved
+   */
+  Set<Library> get resolvedLibraries => _resolvedLibraries;
+
+  /**
+   * Build the HTML element for the given source.
+   *
+   * @param source the source describing the compilation unit
+   * @param unit the AST structure representing the HTML
+   * @throws AnalysisException if the analysis could not be performed
+   */
+  HtmlElementImpl buildHtmlElement(Source source, ht.HtmlUnit unit) {
+    HtmlElementImpl result = new HtmlElementImpl(_context, source.shortName);
+    result.source = source;
+    _htmlElement = result;
+    unit.accept(this);
+    _htmlElement = null;
+    unit.element = result;
+    return result;
+  }
+
+  @override
+  Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
+    if (_parentNodes.contains(node)) {
+      return _reportCircularity(node);
+    }
+    _parentNodes.add(node);
+    try {
+      Source htmlSource = _htmlElement.source;
+      ht.XmlAttributeNode scriptAttribute = _getScriptSourcePath(node);
+      String scriptSourcePath =
+          scriptAttribute == null ? null : scriptAttribute.text;
+      if (node.attributeEnd.type == ht.TokenType.GT &&
+          scriptSourcePath == null) {
+        EmbeddedHtmlScriptElementImpl script =
+            new EmbeddedHtmlScriptElementImpl(node);
+        try {
+          LibraryResolver resolver = new LibraryResolver(_context);
+          LibraryElementImpl library =
+              resolver.resolveEmbeddedLibrary(htmlSource, node.script, true);
+          script.scriptLibrary = library;
+          _resolvedLibraries.addAll(resolver.resolvedLibraries);
+          _errorListener.addAll(resolver.errorListener);
+        } on AnalysisException catch (exception, stackTrace) {
+          //TODO (danrubel): Handle or forward the exception
+          AnalysisEngine.instance.logger.logError(
+              "Could not resolve script tag",
+              new CaughtException(exception, stackTrace));
+        }
+        node.scriptElement = script;
+        _scripts.add(script);
+      } 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 (!_context.exists(scriptSource)) {
+              _reportValueError(HtmlWarningCode.URI_DOES_NOT_EXIST,
+                  scriptAttribute, [scriptSourcePath]);
+            }
+          } on URISyntaxException {
+            _reportValueError(HtmlWarningCode.INVALID_URI, scriptAttribute,
+                [scriptSourcePath]);
+          }
+        }
+        node.scriptElement = script;
+        _scripts.add(script);
+      }
+    } finally {
+      _parentNodes.remove(node);
+    }
+    return null;
+  }
+
+  @override
+  Object visitHtmlUnit(ht.HtmlUnit node) {
+    _parentNodes = new List<ht.XmlTagNode>();
+    _scripts = new List<HtmlScriptElement>();
+    try {
+      node.visitChildren(this);
+      _htmlElement.scripts = new List.from(_scripts);
+    } finally {
+      _scripts = null;
+      _parentNodes = null;
+    }
+    return null;
+  }
+
+  @override
+  Object visitXmlAttributeNode(ht.XmlAttributeNode node) => null;
+
+  @override
+  Object visitXmlTagNode(ht.XmlTagNode node) {
+    if (_parentNodes.contains(node)) {
+      return _reportCircularity(node);
+    }
+    _parentNodes.add(node);
+    try {
+      node.visitChildren(this);
+    } finally {
+      _parentNodes.remove(node);
+    }
+    return null;
+  }
+
+  /**
+   * Return the first source attribute for the given tag node, or `null` if it does not exist.
+   *
+   * @param node the node containing attributes
+   * @return the source attribute contained in the given tag
+   */
+  ht.XmlAttributeNode _getScriptSourcePath(ht.XmlTagNode node) {
+    for (ht.XmlAttributeNode attribute in node.attributes) {
+      if (attribute.name == _SRC) {
+        return attribute;
+      }
+    }
+    return null;
+  }
+
+  Object _reportCircularity(ht.XmlTagNode node) {
+    //
+    // This should not be possible, but we have an error report that suggests
+    // that it happened at least once. This code will guard against infinite
+    // recursion and might help us identify the cause of the issue.
+    //
+    StringBuffer buffer = new StringBuffer();
+    buffer.write("Found circularity in XML nodes: ");
+    bool first = true;
+    for (ht.XmlTagNode pathNode in _parentNodes) {
+      if (first) {
+        first = false;
+      } else {
+        buffer.write(", ");
+      }
+      String tagName = pathNode.tag;
+      if (identical(pathNode, node)) {
+        buffer.write("*");
+        buffer.write(tagName);
+        buffer.write("*");
+      } else {
+        buffer.write(tagName);
+      }
+    }
+    AnalysisEngine.instance.logger.logError(buffer.toString());
+    return null;
+  }
+
+  /**
+   * Report an error with the given error code at the given location. Use the given arguments to
+   * compose the error message.
+   *
+   * @param errorCode the error code of the error to be reported
+   * @param offset the offset of the first character to be highlighted
+   * @param length the number of characters to be highlighted
+   * @param arguments the arguments used to compose the error message
+   */
+  void _reportErrorForOffset(
+      ErrorCode errorCode, int offset, int length, List<Object> arguments) {
+    _errorListener.onError(new AnalysisError(
+        _htmlElement.source, offset, length, errorCode, arguments));
+  }
+
+  /**
+   * Report an error with the given error code at the location of the value of the given attribute.
+   * Use the given arguments to compose the error message.
+   *
+   * @param errorCode the error code of the error to be reported
+   * @param offset the offset of the first character to be highlighted
+   * @param length the number of characters to be highlighted
+   * @param arguments the arguments used to compose the error message
+   */
+  void _reportValueError(ErrorCode errorCode, ht.XmlAttributeNode attribute,
+      List<Object> arguments) {
+    int offset = attribute.valueToken.offset + 1;
+    int length = attribute.valueToken.length - 2;
+    _reportErrorForOffset(errorCode, offset, length, arguments);
+  }
+}
+
+/**
+ * Instances of the class `ImplicitLabelScope` represent the scope statements
+ * that can be the target of unlabeled break and continue statements.
+ */
+class ImplicitLabelScope {
+  /**
+   * The implicit label scope associated with the top level of a function.
+   */
+  static const ImplicitLabelScope ROOT = const ImplicitLabelScope._(null, null);
+
+  /**
+   * The implicit label scope enclosing this implicit label scope.
+   */
+  final ImplicitLabelScope outerScope;
+
+  /**
+   * The statement that acts as a target for break and/or continue statements
+   * at this scoping level.
+   */
+  final Statement statement;
+
+  /**
+   * Private constructor.
+   */
+  const ImplicitLabelScope._(this.outerScope, this.statement);
+
+  /**
+   * Get the statement which should be the target of an unlabeled `break` or
+   * `continue` statement, or `null` if there is no appropriate target.
+   */
+  Statement getTarget(bool isContinue) {
+    if (outerScope == null) {
+      // This scope represents the toplevel of a function body, so it doesn't
+      // match either break or continue.
+      return null;
+    }
+    if (isContinue && statement is SwitchStatement) {
+      return outerScope.getTarget(isContinue);
+    }
+    return statement;
+  }
+
+  /**
+   * Initialize a newly created scope to represent a switch statement or loop
+   * nested within the current scope.  [statement] is the statement associated
+   * with the newly created scope.
+   */
+  ImplicitLabelScope nest(Statement statement) =>
+      new ImplicitLabelScope._(this, statement);
+}
+
+/**
+ * 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].
+ *
+ * While this class does not yet have support for an "Organize Imports" action, this logic built up
+ * in this class could be used for such an action in the future.
+ */
+class ImportsVerifier /*extends RecursiveAstVisitor<Object>*/ {
+  /**
+   * A list of [ImportDirective]s that the current library imports, as identifiers are visited
+   * by this visitor and an import has been identified as being used by the library, the
+   * [ImportDirective] is removed from this list. After all the sources in the library have
+   * been evaluated, this list represents the set of unused imports.
+   *
+   * See [ImportsVerifier.generateUnusedImportErrors].
+   */
+  final List<ImportDirective> _unusedImports = <ImportDirective>[];
+
+  /**
+   * After the list of [unusedImports] has been computed, this list is a proper subset of the
+   * unused imports that are listed more than once.
+   */
+  final List<ImportDirective> _duplicateImports = <ImportDirective>[];
+
+  /**
+   * This is a map between the set of [LibraryElement]s that the current library imports, and
+   * a list of [ImportDirective]s that imports the library. In cases where the current library
+   * imports a library with a single directive (such as `import lib1.dart;`), the library
+   * element will map to a list of one [ImportDirective], which will then be removed from the
+   * [unusedImports] list. In cases where the current library imports a library with multiple
+   * directives (such as `import lib1.dart; import lib1.dart show C;`), the
+   * [LibraryElement] will be mapped to a list of the import directives, and the namespace
+   * will need to be used to compute the correct [ImportDirective] being used, see
+   * [namespaceMap].
+   */
+  final HashMap<LibraryElement, List<ImportDirective>> _libraryMap =
+      new HashMap<LibraryElement, List<ImportDirective>>();
+
+  /**
+   * In cases where there is more than one import directive per library element, this mapping is
+   * used to determine which of the multiple import directives are used by generating a
+   * [Namespace] for each of the imports to do lookups in the same way that they are done from
+   * the [ElementResolver].
+   */
+  final HashMap<ImportDirective, Namespace> _namespaceMap =
+      new HashMap<ImportDirective, Namespace>();
+
+  /**
+   * This is a map between prefix elements and the import directives from which they are derived. In
+   * cases where a type is referenced via a prefix element, the import directive can be marked as
+   * used (removed from the unusedImports) by looking at the resolved `lib` in `lib.X`,
+   * instead of looking at which library the `lib.X` resolves.
+   *
+   * TODO (jwren) Since multiple [ImportDirective]s can share the same [PrefixElement],
+   * it is possible to have an unreported unused import in situations where two imports use the same
+   * prefix and at least one import directive is used.
+   */
+  final HashMap<PrefixElement, List<ImportDirective>> _prefixElementMap =
+      new HashMap<PrefixElement, List<ImportDirective>>();
+
+  void addImports(CompilationUnit node) {
+    for (Directive directive in node.directives) {
+      if (directive is ImportDirective) {
+        ImportDirective importDirective = directive;
+        LibraryElement libraryElement = importDirective.uriElement;
+        if (libraryElement != null) {
+          _unusedImports.add(importDirective);
+          //
+          // Initialize prefixElementMap
+          //
+          if (importDirective.asKeyword != null) {
+            SimpleIdentifier prefixIdentifier = importDirective.prefix;
+            if (prefixIdentifier != null) {
+              Element element = prefixIdentifier.staticElement;
+              if (element is PrefixElement) {
+                PrefixElement prefixElementKey = element;
+                List<ImportDirective> list =
+                    _prefixElementMap[prefixElementKey];
+                if (list == null) {
+                  list = new List<ImportDirective>();
+                  _prefixElementMap[prefixElementKey] = list;
+                }
+                list.add(importDirective);
+              }
+              // TODO (jwren) Can the element ever not be a PrefixElement?
+            }
+          }
+          //
+          // Initialize libraryMap: libraryElement -> importDirective
+          //
+          _putIntoLibraryMap(libraryElement, importDirective);
+          //
+          // For this new addition to the libraryMap, also recursively add any
+          // exports from the libraryElement.
+          //
+          _addAdditionalLibrariesForExports(
+              libraryElement, importDirective, new List<LibraryElement>());
+        }
+      }
+    }
+    if (_unusedImports.length > 1) {
+      // order the list of unusedImports to find duplicates in faster than
+      // O(n^2) time
+      List<ImportDirective> importDirectiveArray =
+          new List<ImportDirective>.from(_unusedImports);
+      importDirectiveArray.sort(ImportDirective.COMPARATOR);
+      ImportDirective currentDirective = importDirectiveArray[0];
+      for (int i = 1; i < importDirectiveArray.length; i++) {
+        ImportDirective nextDirective = importDirectiveArray[i];
+        if (ImportDirective.COMPARATOR(currentDirective, nextDirective) == 0) {
+          // Add either the currentDirective or nextDirective depending on which
+          // comes second, this guarantees that the first of the duplicates
+          // won't be highlighted.
+          if (currentDirective.offset < nextDirective.offset) {
+            _duplicateImports.add(nextDirective);
+          } else {
+            _duplicateImports.add(currentDirective);
+          }
+        }
+        currentDirective = nextDirective;
+      }
+    }
+  }
+
+  /**
+   * Any time after the defining compilation unit has been visited by this visitor, this method can
+   * be called to report an [HintCode.DUPLICATE_IMPORT] hint for each of the import directives
+   * in the [duplicateImports] list.
+   *
+   * @param errorReporter the error reporter to report the set of [HintCode.DUPLICATE_IMPORT]
+   *          hints to
+   */
+  void generateDuplicateImportHints(ErrorReporter errorReporter) {
+    for (ImportDirective duplicateImport in _duplicateImports) {
+      errorReporter.reportErrorForNode(
+          HintCode.DUPLICATE_IMPORT, duplicateImport.uri);
+    }
+  }
+
+  /**
+   * After all of the compilation units have been visited by this visitor, this method can be called
+   * to report an [HintCode.UNUSED_IMPORT] hint for each of the import directives in the
+   * [unusedImports] list.
+   *
+   * @param errorReporter the error reporter to report the set of [HintCode.UNUSED_IMPORT]
+   *          hints to
+   */
+  void generateUnusedImportHints(ErrorReporter errorReporter) {
+    for (ImportDirective unusedImport in _unusedImports) {
+      // Check that the import isn't dart:core
+      ImportElement importElement = unusedImport.element;
+      if (importElement != null) {
+        LibraryElement libraryElement = importElement.importedLibrary;
+        if (libraryElement != null && libraryElement.isDartCore) {
+          continue;
+        }
+      }
+      errorReporter.reportErrorForNode(
+          HintCode.UNUSED_IMPORT, unusedImport.uri);
+    }
+  }
+
+  /**
+   * Remove elements from [_unusedImports] using the given [usedElements].
+   */
+  void removeUsedElements(UsedImportedElements usedElements) {
+    // Stop if all the imports are known to be used.
+    if (_unusedImports.isEmpty) {
+      return;
+    }
+    // Process import prefixes.
+    for (PrefixElement prefix in usedElements.prefixes) {
+      List<ImportDirective> importDirectives = _prefixElementMap[prefix];
+      if (importDirectives != null) {
+        for (ImportDirective importDirective in importDirectives) {
+          _unusedImports.remove(importDirective);
+        }
+      }
+    }
+    // Process top-level elements.
+    for (Element element in usedElements.elements) {
+      // Stop if all the imports are known to be used.
+      if (_unusedImports.isEmpty) {
+        return;
+      }
+      // Prepare import directives for this library.
+      LibraryElement library = element.library;
+      List<ImportDirective> importsLibrary = _libraryMap[library];
+      if (importsLibrary == null) {
+        continue;
+      }
+      // If there is only one import directive for this library, then it must be
+      // the directive that this element is imported with, remove it from the
+      // unusedImports list.
+      if (importsLibrary.length == 1) {
+        ImportDirective usedImportDirective = importsLibrary[0];
+        _unusedImports.remove(usedImportDirective);
+        continue;
+      }
+      // Otherwise, find import directives using namespaces.
+      String name = element.displayName;
+      for (ImportDirective importDirective in importsLibrary) {
+        Namespace namespace = _computeNamespace(importDirective);
+        if (namespace != null && namespace.get(name) != null) {
+          _unusedImports.remove(importDirective);
+        }
+      }
+    }
+  }
+
+  /**
+   * Recursively add any exported library elements into the [libraryMap].
+   */
+  void _addAdditionalLibrariesForExports(LibraryElement library,
+      ImportDirective importDirective, List<LibraryElement> exportPath) {
+    if (exportPath.contains(library)) {
+      return;
+    }
+    exportPath.add(library);
+    for (LibraryElement exportedLibraryElt in library.exportedLibraries) {
+      _putIntoLibraryMap(exportedLibraryElt, importDirective);
+      _addAdditionalLibrariesForExports(
+          exportedLibraryElt, importDirective, exportPath);
+    }
+  }
+
+  /**
+   * Lookup and return the [Namespace] from the [namespaceMap], if the map does not
+   * have the computed namespace, compute it and cache it in the map. If the import directive is not
+   * resolved or is not resolvable, `null` is returned.
+   *
+   * @param importDirective the import directive used to compute the returned namespace
+   * @return the computed or looked up [Namespace]
+   */
+  Namespace _computeNamespace(ImportDirective importDirective) {
+    Namespace namespace = _namespaceMap[importDirective];
+    if (namespace == null) {
+      // If the namespace isn't in the namespaceMap, then compute and put it in
+      // the map.
+      ImportElement importElement = importDirective.element;
+      if (importElement != null) {
+        NamespaceBuilder builder = new NamespaceBuilder();
+        namespace = builder.createImportNamespaceForDirective(importElement);
+        _namespaceMap[importDirective] = namespace;
+      }
+    }
+    return namespace;
+  }
+
+  /**
+   * The [libraryMap] is a mapping between a library elements and a list of import
+   * directives, but when adding these mappings into the [libraryMap], this method can be
+   * used to simply add the mapping between the library element an an import directive without
+   * needing to check to see if a list needs to be created.
+   */
+  void _putIntoLibraryMap(
+      LibraryElement libraryElement, ImportDirective importDirective) {
+    List<ImportDirective> importList = _libraryMap[libraryElement];
+    if (importList == null) {
+      importList = new List<ImportDirective>();
+      _libraryMap[libraryElement] = importList;
+    }
+    importList.add(importDirective);
+  }
+}
+
+/**
+ * Instances of the class `InheritanceManager` manage the knowledge of where class members
+ * (methods, getters & setters) are inherited from.
+ */
+class InheritanceManager {
+  /**
+   * The [LibraryElement] that is managed by this manager.
+   */
+  LibraryElement _library;
+
+  /**
+   * This is a mapping between each [ClassElement] and a map between the [String] member
+   * names and the associated [ExecutableElement] in the mixin and superclass chain.
+   */
+  HashMap<ClassElement, MemberMap> _classLookup;
+
+  /**
+   * This is a mapping between each [ClassElement] and a map between the [String] member
+   * names and the associated [ExecutableElement] in the interface set.
+   */
+  HashMap<ClassElement, MemberMap> _interfaceLookup;
+
+  /**
+   * A map between each visited [ClassElement] and the set of [AnalysisError]s found on
+   * the class element.
+   */
+  HashMap<ClassElement, HashSet<AnalysisError>> _errorsInClassElement =
+      new HashMap<ClassElement, HashSet<AnalysisError>>();
+
+  /**
+   * Initialize a newly created inheritance manager.
+   *
+   * @param library the library element context that the inheritance mappings are being generated
+   */
+  InheritanceManager(LibraryElement library) {
+    this._library = library;
+    _classLookup = new HashMap<ClassElement, MemberMap>();
+    _interfaceLookup = new HashMap<ClassElement, MemberMap>();
+  }
+
+  /**
+   * Set the new library element context.
+   *
+   * @param library the new library element
+   */
+  void set libraryElement(LibraryElement library) {
+    this._library = library;
+  }
+
+  /**
+   * Return the set of [AnalysisError]s found on the passed [ClassElement], or
+   * `null` if there are none.
+   *
+   * @param classElt the class element to query
+   * @return the set of [AnalysisError]s found on the passed [ClassElement], or
+   *         `null` if there are none
+   */
+  HashSet<AnalysisError> getErrors(ClassElement classElt) =>
+      _errorsInClassElement[classElt];
+
+  /**
+   * Get and return a mapping between the set of all string names of the members inherited from the
+   * passed [ClassElement] superclass hierarchy, and the associated [ExecutableElement].
+   *
+   * @param classElt the class element to query
+   * @return a mapping between the set of all members inherited from the passed [ClassElement]
+   *         superclass hierarchy, and the associated [ExecutableElement]
+   */
+  MemberMap getMapOfMembersInheritedFromClasses(ClassElement classElt) =>
+      _computeClassChainLookupMap(classElt, new HashSet<ClassElement>());
+
+  /**
+   * Get and return a mapping between the set of all string names of the members inherited from the
+   * passed [ClassElement] interface hierarchy, and the associated [ExecutableElement].
+   *
+   * @param classElt the class element to query
+   * @return a mapping between the set of all string names of the members inherited from the passed
+   *         [ClassElement] interface hierarchy, and the associated [ExecutableElement].
+   */
+  MemberMap getMapOfMembersInheritedFromInterfaces(ClassElement classElt) =>
+      _computeInterfaceLookupMap(classElt, new HashSet<ClassElement>());
+
+  /**
+   * Given some [ClassElement] and some member name, this returns the
+   * [ExecutableElement] that the class inherits from the mixins,
+   * superclasses or interfaces, that has the member name, if no member is inherited `null` is
+   * returned.
+   *
+   * @param classElt the class element to query
+   * @param memberName the name of the executable element to find and return
+   * @return the inherited executable element with the member name, or `null` if no such
+   *         member exists
+   */
+  ExecutableElement lookupInheritance(
+      ClassElement classElt, String memberName) {
+    if (memberName == null || memberName.isEmpty) {
+      return null;
+    }
+    ExecutableElement executable = _computeClassChainLookupMap(
+        classElt, new HashSet<ClassElement>()).get(memberName);
+    if (executable == null) {
+      return _computeInterfaceLookupMap(classElt, new HashSet<ClassElement>())
+          .get(memberName);
+    }
+    return executable;
+  }
+
+  /**
+   * Given some [ClassElement] and some member name, this returns the
+   * [ExecutableElement] that the class either declares itself, or
+   * inherits, that has the member name, if no member is inherited `null` is returned.
+   *
+   * @param classElt the class element to query
+   * @param memberName the name of the executable element to find and return
+   * @return the inherited executable element with the member name, or `null` if no such
+   *         member exists
+   */
+  ExecutableElement lookupMember(ClassElement classElt, String memberName) {
+    ExecutableElement element = _lookupMemberInClass(classElt, memberName);
+    if (element != null) {
+      return element;
+    }
+    return lookupInheritance(classElt, memberName);
+  }
+
+  /**
+   * Given some [InterfaceType] and some member name, this returns the
+   * [FunctionType] of the [ExecutableElement] that the
+   * class either declares itself, or inherits, that has the member name, if no member is inherited
+   * `null` is returned. The returned [FunctionType] has all type
+   * parameters substituted with corresponding type arguments from the given [InterfaceType].
+   *
+   * @param interfaceType the interface type to query
+   * @param memberName the name of the executable element to find and return
+   * @return the member's function type, or `null` if no such member exists
+   */
+  FunctionType lookupMemberType(
+      InterfaceType interfaceType, String memberName) {
+    ExecutableElement iteratorMember =
+        lookupMember(interfaceType.element, memberName);
+    if (iteratorMember == null) {
+      return null;
+    }
+    return substituteTypeArgumentsInMemberFromInheritance(
+        iteratorMember.type, memberName, interfaceType);
+  }
+
+  /**
+   * Determine the set of methods which is overridden by the given class member. If no member is
+   * inherited, an empty list is returned. If one of the inherited members is a
+   * [MultiplyInheritedExecutableElement], then it is expanded into its constituent inherited
+   * elements.
+   *
+   * @param classElt the class to query
+   * @param memberName the name of the class member to query
+   * @return a list of overridden methods
+   */
+  List<ExecutableElement> lookupOverrides(
+      ClassElement classElt, String memberName) {
+    List<ExecutableElement> result = new List<ExecutableElement>();
+    if (memberName == null || memberName.isEmpty) {
+      return result;
+    }
+    List<MemberMap> interfaceMaps =
+        _gatherInterfaceLookupMaps(classElt, new HashSet<ClassElement>());
+    if (interfaceMaps != null) {
+      for (MemberMap interfaceMap in interfaceMaps) {
+        ExecutableElement overriddenElement = interfaceMap.get(memberName);
+        if (overriddenElement != null) {
+          if (overriddenElement is MultiplyInheritedExecutableElement) {
+            MultiplyInheritedExecutableElement multiplyInheritedElement =
+                overriddenElement;
+            for (ExecutableElement element
+                in multiplyInheritedElement.inheritedElements) {
+              result.add(element);
+            }
+          } else {
+            result.add(overriddenElement);
+          }
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * This method takes some inherited [FunctionType], and resolves all the parameterized types
+   * in the function type, dependent on the class in which it is being overridden.
+   *
+   * @param baseFunctionType the function type that is being overridden
+   * @param memberName the name of the member, this is used to lookup the inheritance path of the
+   *          override
+   * @param definingType the type that is overriding the member
+   * @return the passed function type with any parameterized types substituted
+   */
+  FunctionType substituteTypeArgumentsInMemberFromInheritance(
+      FunctionType baseFunctionType,
+      String memberName,
+      InterfaceType definingType) {
+    // if the baseFunctionType is null, or does not have any parameters,
+    // return it.
+    if (baseFunctionType == null ||
+        baseFunctionType.typeArguments.length == 0) {
+      return baseFunctionType;
+    }
+    // First, generate the path from the defining type to the overridden member
+    Queue<InterfaceType> inheritancePath = new Queue<InterfaceType>();
+    _computeInheritancePath(inheritancePath, definingType, memberName);
+    if (inheritancePath == null || inheritancePath.isEmpty) {
+      // TODO(jwren) log analysis engine error
+      return baseFunctionType;
+    }
+    FunctionType functionTypeToReturn = baseFunctionType;
+    // loop backward through the list substituting as we go:
+    while (!inheritancePath.isEmpty) {
+      InterfaceType lastType = inheritancePath.removeLast();
+      List<DartType> parameterTypes = lastType.element.type.typeArguments;
+      List<DartType> argumentTypes = lastType.typeArguments;
+      functionTypeToReturn =
+          functionTypeToReturn.substitute2(argumentTypes, parameterTypes);
+    }
+    return functionTypeToReturn;
+  }
+
+  /**
+   * Compute and return a mapping between the set of all string names of the members inherited from
+   * the passed [ClassElement] superclass hierarchy, and the associated
+   * [ExecutableElement].
+   *
+   * @param classElt the class element to query
+   * @param visitedClasses a set of visited classes passed back into this method when it calls
+   *          itself recursively
+   * @return a mapping between the set of all string names of the members inherited from the passed
+   *         [ClassElement] superclass hierarchy, and the associated [ExecutableElement]
+   */
+  MemberMap _computeClassChainLookupMap(
+      ClassElement classElt, HashSet<ClassElement> visitedClasses) {
+    MemberMap resultMap = _classLookup[classElt];
+    if (resultMap != null) {
+      return resultMap;
+    } else {
+      resultMap = new MemberMap();
+    }
+    ClassElement superclassElt = null;
+    InterfaceType supertype = classElt.supertype;
+    if (supertype != null) {
+      superclassElt = supertype.element;
+    } else {
+      // classElt is Object
+      _classLookup[classElt] = resultMap;
+      return resultMap;
+    }
+    if (superclassElt != null) {
+      if (!visitedClasses.contains(superclassElt)) {
+        visitedClasses.add(superclassElt);
+        try {
+          resultMap = new MemberMap.from(
+              _computeClassChainLookupMap(superclassElt, visitedClasses));
+          //
+          // Substitute the super types down the hierarchy.
+          //
+          _substituteTypeParametersDownHierarchy(supertype, resultMap);
+          //
+          // Include the members from the superclass in the resultMap.
+          //
+          _recordMapWithClassMembers(resultMap, supertype, false);
+        } finally {
+          visitedClasses.remove(superclassElt);
+        }
+      } else {
+        // This case happens only when the superclass was previously visited and
+        // not in the lookup, meaning this is meant to shorten the compute for
+        // recursive cases.
+        _classLookup[superclassElt] = resultMap;
+        return resultMap;
+      }
+    }
+    //
+    // Include the members from the mixins in the resultMap.  If there are
+    // multiple mixins, visit them in the order listed so that methods in later
+    // mixins will overwrite identically-named methods in earlier mixins.
+    //
+    List<InterfaceType> mixins = classElt.mixins;
+    for (InterfaceType mixin in mixins) {
+      ClassElement mixinElement = mixin.element;
+      if (mixinElement != null) {
+        if (!visitedClasses.contains(mixinElement)) {
+          visitedClasses.add(mixinElement);
+          try {
+            MemberMap map = new MemberMap.from(
+                _computeClassChainLookupMap(mixinElement, visitedClasses));
+            //
+            // Substitute the super types down the hierarchy.
+            //
+            _substituteTypeParametersDownHierarchy(mixin, map);
+            //
+            // Include the members from the superclass in the resultMap.
+            //
+            _recordMapWithClassMembers(map, mixin, false);
+            //
+            // Add the members from map into result map.
+            //
+            for (int j = 0; j < map.size; j++) {
+              String key = map.getKey(j);
+              ExecutableElement value = map.getValue(j);
+              if (key != null) {
+                ClassElement definingClass = value
+                    .getAncestor((Element element) => element is ClassElement);
+                if (!definingClass.type.isObject) {
+                  ExecutableElement existingValue = resultMap.get(key);
+                  if (existingValue == null ||
+                      (existingValue != null && !_isAbstract(value))) {
+                    resultMap.put(key, value);
+                  }
+                }
+              }
+            }
+          } finally {
+            visitedClasses.remove(mixinElement);
+          }
+        } else {
+          // This case happens only when the superclass was previously visited
+          // and not in the lookup, meaning this is meant to shorten the compute
+          // for recursive cases.
+          _classLookup[mixinElement] = resultMap;
+          return resultMap;
+        }
+      }
+    }
+    _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,
+   *          when this method is called an empty [LinkedList] should be provided
+   * @param currentType the current type in the inheritance path
+   * @param memberName the name of the member that is being looked up the inheritance path
+   */
+  void _computeInheritancePath(Queue<InterfaceType> chain,
+      InterfaceType currentType, String memberName) {
+    // TODO (jwren) create a public version of this method which doesn't require
+    // the initial chain to be provided, then provided tests for this
+    // functionality in InheritanceManagerTest
+    chain.add(currentType);
+    ClassElement classElt = currentType.element;
+    InterfaceType supertype = classElt.supertype;
+    // Base case- reached Object
+    if (supertype == null) {
+      // Looked up the chain all the way to Object, return null.
+      // This should never happen.
+      return;
+    }
+    // If we are done, return the chain
+    // We are not done if this is the first recursive call on this method.
+    if (chain.length != 1) {
+      // We are done however if the member is in this classElt
+      if (_lookupMemberInClass(classElt, memberName) != null) {
+        return;
+      }
+    }
+    // Mixins- note that mixins call lookupMemberInClass, not lookupMember
+    List<InterfaceType> mixins = classElt.mixins;
+    for (int i = mixins.length - 1; i >= 0; i--) {
+      ClassElement mixinElement = mixins[i].element;
+      if (mixinElement != null) {
+        ExecutableElement elt = _lookupMemberInClass(mixinElement, memberName);
+        if (elt != null) {
+          // this is equivalent (but faster than) calling this method
+          // recursively
+          // (return computeInheritancePath(chain, mixins[i], memberName);)
+          chain.add(mixins[i]);
+          return;
+        }
+      }
+    }
+    // Superclass
+    ClassElement superclassElt = supertype.element;
+    if (lookupMember(superclassElt, memberName) != null) {
+      _computeInheritancePath(chain, supertype, memberName);
+      return;
+    }
+    // Interfaces
+    List<InterfaceType> interfaces = classElt.interfaces;
+    for (InterfaceType interfaceType in interfaces) {
+      ClassElement interfaceElement = interfaceType.element;
+      if (interfaceElement != null &&
+          lookupMember(interfaceElement, memberName) != null) {
+        _computeInheritancePath(chain, interfaceType, memberName);
+        return;
+      }
+    }
+  }
+
+  /**
+   * Compute and return a mapping between the set of all string names of the members inherited from
+   * the passed [ClassElement] interface hierarchy, and the associated
+   * [ExecutableElement].
+   *
+   * @param classElt the class element to query
+   * @param visitedInterfaces a set of visited classes passed back into this method when it calls
+   *          itself recursively
+   * @return a mapping between the set of all string names of the members inherited from the passed
+   *         [ClassElement] interface hierarchy, and the associated [ExecutableElement]
+   */
+  MemberMap _computeInterfaceLookupMap(
+      ClassElement classElt, HashSet<ClassElement> visitedInterfaces) {
+    MemberMap resultMap = _interfaceLookup[classElt];
+    if (resultMap != null) {
+      return resultMap;
+    }
+    List<MemberMap> lookupMaps =
+        _gatherInterfaceLookupMaps(classElt, visitedInterfaces);
+    if (lookupMaps == null) {
+      resultMap = new MemberMap();
+    } else {
+      HashMap<String, List<ExecutableElement>> unionMap =
+          _unionInterfaceLookupMaps(lookupMaps);
+      resultMap = _resolveInheritanceLookup(classElt, unionMap);
+    }
+    _interfaceLookup[classElt] = resultMap;
+    return resultMap;
+  }
+
+  /**
+   * Collect a list of interface lookup maps whose elements correspond to all of the classes
+   * directly above [classElt] in the class hierarchy (the direct superclass if any, all
+   * mixins, and all direct superinterfaces). Each item in the list is the interface lookup map
+   * returned by [computeInterfaceLookupMap] for the corresponding super, except with type
+   * parameters appropriately substituted.
+   *
+   * @param classElt the class element to query
+   * @param visitedInterfaces a set of visited classes passed back into this method when it calls
+   *          itself recursively
+   * @return `null` if there was a problem (such as a loop in the class hierarchy) or if there
+   *         are no classes above this one in the class hierarchy. Otherwise, a list of interface
+   *         lookup maps.
+   */
+  List<MemberMap> _gatherInterfaceLookupMaps(
+      ClassElement classElt, HashSet<ClassElement> visitedInterfaces) {
+    InterfaceType supertype = classElt.supertype;
+    ClassElement superclassElement =
+        supertype != null ? supertype.element : null;
+    List<InterfaceType> mixins = classElt.mixins;
+    List<InterfaceType> interfaces = classElt.interfaces;
+    // Recursively collect the list of mappings from all of the interface types
+    List<MemberMap> lookupMaps = new List<MemberMap>();
+    //
+    // Superclass element
+    //
+    if (superclassElement != null) {
+      if (!visitedInterfaces.contains(superclassElement)) {
+        try {
+          visitedInterfaces.add(superclassElement);
+          //
+          // Recursively compute the map for the super type.
+          //
+          MemberMap map =
+              _computeInterfaceLookupMap(superclassElement, visitedInterfaces);
+          map = new MemberMap.from(map);
+          //
+          // Substitute the super type down the hierarchy.
+          //
+          _substituteTypeParametersDownHierarchy(supertype, map);
+          //
+          // Add any members from the super type into the map as well.
+          //
+          _recordMapWithClassMembers(map, supertype, true);
+          lookupMaps.add(map);
+        } finally {
+          visitedInterfaces.remove(superclassElement);
+        }
+      } else {
+        return null;
+      }
+    }
+    //
+    // Mixin elements
+    //
+    for (int i = mixins.length - 1; i >= 0; i--) {
+      InterfaceType mixinType = mixins[i];
+      ClassElement mixinElement = mixinType.element;
+      if (mixinElement != null) {
+        if (!visitedInterfaces.contains(mixinElement)) {
+          try {
+            visitedInterfaces.add(mixinElement);
+            //
+            // Recursively compute the map for the mixin.
+            //
+            MemberMap map =
+                _computeInterfaceLookupMap(mixinElement, visitedInterfaces);
+            map = new MemberMap.from(map);
+            //
+            // Substitute the mixin type down the hierarchy.
+            //
+            _substituteTypeParametersDownHierarchy(mixinType, map);
+            //
+            // Add any members from the mixin type into the map as well.
+            //
+            _recordMapWithClassMembers(map, mixinType, true);
+            lookupMaps.add(map);
+          } finally {
+            visitedInterfaces.remove(mixinElement);
+          }
+        } else {
+          return null;
+        }
+      }
+    }
+    //
+    // Interface elements
+    //
+    for (InterfaceType interfaceType in interfaces) {
+      ClassElement interfaceElement = interfaceType.element;
+      if (interfaceElement != null) {
+        if (!visitedInterfaces.contains(interfaceElement)) {
+          try {
+            visitedInterfaces.add(interfaceElement);
+            //
+            // Recursively compute the map for the interfaces.
+            //
+            MemberMap map =
+                _computeInterfaceLookupMap(interfaceElement, visitedInterfaces);
+            map = new MemberMap.from(map);
+            //
+            // Substitute the supertypes down the hierarchy
+            //
+            _substituteTypeParametersDownHierarchy(interfaceType, map);
+            //
+            // And add any members from the interface into the map as well.
+            //
+            _recordMapWithClassMembers(map, interfaceType, true);
+            lookupMaps.add(map);
+          } finally {
+            visitedInterfaces.remove(interfaceElement);
+          }
+        } else {
+          return null;
+        }
+      }
+    }
+    if (lookupMaps.length == 0) {
+      return null;
+    }
+    return lookupMaps;
+  }
+
+  /**
+   * Given some [ClassElement], this method finds and returns the [ExecutableElement] of
+   * the passed name in the class element. Static members, members in super types and members not
+   * accessible from the current library are not considered.
+   *
+   * @param classElt the class element to query
+   * @param memberName the name of the member to lookup in the class
+   * @return the found [ExecutableElement], or `null` if no such member was found
+   */
+  ExecutableElement _lookupMemberInClass(
+      ClassElement classElt, String memberName) {
+    List<MethodElement> methods = classElt.methods;
+    for (MethodElement method in methods) {
+      if (memberName == method.name &&
+          method.isAccessibleIn(_library) &&
+          !method.isStatic) {
+        return method;
+      }
+    }
+    List<PropertyAccessorElement> accessors = classElt.accessors;
+    for (PropertyAccessorElement accessor in accessors) {
+      if (memberName == accessor.name &&
+          accessor.isAccessibleIn(_library) &&
+          !accessor.isStatic) {
+        return accessor;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Record the passed map with the set of all members (methods, getters and setters) in the type
+   * into the passed map.
+   *
+   * @param map some non-`null` map to put the methods and accessors from the passed
+   *          [ClassElement] into
+   * @param type the type that will be recorded into the passed map
+   * @param doIncludeAbstract `true` if abstract members will be put into the map
+   */
+  void _recordMapWithClassMembers(
+      MemberMap map, InterfaceType type, bool doIncludeAbstract) {
+    List<MethodElement> methods = type.methods;
+    for (MethodElement method in methods) {
+      if (method.isAccessibleIn(_library) &&
+          !method.isStatic &&
+          (doIncludeAbstract || !method.isAbstract)) {
+        map.put(method.name, method);
+      }
+    }
+    List<PropertyAccessorElement> accessors = type.accessors;
+    for (PropertyAccessorElement accessor in accessors) {
+      if (accessor.isAccessibleIn(_library) &&
+          !accessor.isStatic &&
+          (doIncludeAbstract || !accessor.isAbstract)) {
+        map.put(accessor.name, accessor);
+      }
+    }
+  }
+
+  /**
+   * This method is used to report errors on when they are found computing inheritance information.
+   * See [ErrorVerifier.checkForInconsistentMethodInheritance] to see where these generated
+   * error codes are reported back into the analysis engine.
+   *
+   * @param classElt the location of the source for which the exception occurred
+   * @param offset the offset of the location of the error
+   * @param length the length of the location of the error
+   * @param errorCode the error code to be associated with this error
+   * @param arguments the arguments used to build the error message
+   */
+  void _reportError(ClassElement classElt, int offset, int length,
+      ErrorCode errorCode, List<Object> arguments) {
+    HashSet<AnalysisError> errorSet = _errorsInClassElement[classElt];
+    if (errorSet == null) {
+      errorSet = new HashSet<AnalysisError>();
+      _errorsInClassElement[classElt] = errorSet;
+    }
+    errorSet.add(new AnalysisError(
+        classElt.source, offset, length, errorCode, arguments));
+  }
+
+  /**
+   * Given the set of methods defined by classes above [classElt] in the class hierarchy,
+   * apply the appropriate inheritance rules to determine those methods inherited by or overridden
+   * by [classElt]. Also report static warnings
+   * [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE] and
+   * [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD] if appropriate.
+   *
+   * @param classElt the class element to query.
+   * @param unionMap a mapping from method name to the set of unique (in terms of signature) methods
+   *          defined in superclasses of [classElt].
+   * @return the inheritance lookup map for [classElt].
+   */
+  MemberMap _resolveInheritanceLookup(ClassElement classElt,
+      HashMap<String, List<ExecutableElement>> unionMap) {
+    MemberMap resultMap = new MemberMap();
+    unionMap.forEach((String key, List<ExecutableElement> list) {
+      int numOfEltsWithMatchingNames = list.length;
+      if (numOfEltsWithMatchingNames == 1) {
+        //
+        // Example: class A inherits only 1 method named 'm'.
+        // Since it is the only such method, it is inherited.
+        // Another example: class A inherits 2 methods named 'm' from 2
+        // different interfaces, but they both have the same signature, so it is
+        // the method inherited.
+        //
+        resultMap.put(key, list[0]);
+      } else {
+        //
+        // Then numOfEltsWithMatchingNames > 1, check for the warning cases.
+        //
+        bool allMethods = true;
+        bool allSetters = true;
+        bool allGetters = true;
+        for (ExecutableElement executableElement in list) {
+          if (executableElement is PropertyAccessorElement) {
+            allMethods = false;
+            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(list);
+          List<FunctionType> executableElementTypes =
+              new List<FunctionType>(numOfEltsWithMatchingNames);
+          for (int i = 0; i < numOfEltsWithMatchingNames; i++) {
+            executableElementTypes[i] = elements[i].type;
+          }
+          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) {
+              subtypesOfAllOtherTypesIndexes.add(i);
+            }
+          }
+          //
+          // 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) {
+              //
+              // Determine if the current class has a method or accessor with
+              // the member name, if it does then then this class does not
+              // "inherit" from any of the supertypes. See issue 16134.
+              //
+              bool classHasMember = false;
+              if (allMethods) {
+                classHasMember = classElt.getMethod(key) != null;
+              } else {
+                List<PropertyAccessorElement> accessors = classElt.accessors;
+                for (int i = 0; i < accessors.length; i++) {
+                  if (accessors[i].name == key) {
+                    classHasMember = true;
+                  }
+                }
+              }
+              //
+              // Example: class A inherited only 2 method named 'm'.
+              // One has the function type '() -> int' and one has the function
+              // type '() -> String'. Since neither is a subtype of the other,
+              // we create a warning, and have this class inherit nothing.
+              //
+              if (!classHasMember) {
+                String firstTwoFuntionTypesStr =
+                    "${executableElementTypes[0]}, ${executableElementTypes[1]}";
+                _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);
+              resultMap.put(key, mergedExecutableElement);
+            }
+          }
+        } else {
+          _reportError(
+              classElt,
+              classElt.nameOffset,
+              classElt.displayName.length,
+              StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
+              [key]);
+        }
+      }
+    });
+    return resultMap;
+  }
+
+  /**
+   * Loop through all of the members in some [MemberMap], performing type parameter
+   * substitutions using a passed supertype.
+   *
+   * @param superType the supertype to substitute into the members of the [MemberMap]
+   * @param map the MemberMap to perform the substitutions on
+   */
+  void _substituteTypeParametersDownHierarchy(
+      InterfaceType superType, MemberMap map) {
+    for (int i = 0; i < map.size; i++) {
+      ExecutableElement executableElement = map.getValue(i);
+      if (executableElement is MethodMember) {
+        executableElement =
+            MethodMember.from(executableElement as MethodMember, superType);
+        map.setValue(i, executableElement);
+      } else if (executableElement is PropertyAccessorMember) {
+        executableElement = PropertyAccessorMember.from(
+            executableElement as PropertyAccessorMember, superType);
+        map.setValue(i, executableElement);
+      }
+    }
+  }
+
+  /**
+   * Union all of the [lookupMaps] together into a single map, grouping the ExecutableElements
+   * into a list where none of the elements are equal where equality is determined by having equal
+   * function types. (We also take note too of the kind of the element: ()->int and () -> int may
+   * not be equal if one is a getter and the other is a method.)
+   *
+   * @param lookupMaps the maps to be unioned together.
+   * @return the resulting union map.
+   */
+  HashMap<String, List<ExecutableElement>> _unionInterfaceLookupMaps(
+      List<MemberMap> lookupMaps) {
+    HashMap<String, List<ExecutableElement>> unionMap =
+        new HashMap<String, List<ExecutableElement>>();
+    for (MemberMap lookupMap in lookupMaps) {
+      int lookupMapSize = lookupMap.size;
+      for (int i = 0; i < lookupMapSize; i++) {
+        // Get the string key, if null, break.
+        String key = lookupMap.getKey(i);
+        if (key == null) {
+          break;
+        }
+        // Get the list value out of the unionMap
+        List<ExecutableElement> list = unionMap[key];
+        // If we haven't created such a map for this key yet, do create it and
+        // put the list entry into the unionMap.
+        if (list == null) {
+          list = new List<ExecutableElement>();
+          unionMap[key] = list;
+        }
+        // Fetch the entry out of this lookupMap
+        ExecutableElement newExecutableElementEntry = lookupMap.getValue(i);
+        if (list.isEmpty) {
+          // If the list is empty, just the new value
+          list.add(newExecutableElementEntry);
+        } else {
+          // Otherwise, only add the newExecutableElementEntry if it isn't
+          // already in the list, this covers situation where a class inherits
+          // two methods (or two getters) that are identical.
+          bool alreadyInList = false;
+          bool isMethod1 = newExecutableElementEntry is MethodElement;
+          for (ExecutableElement executableElementInList in list) {
+            bool isMethod2 = executableElementInList is MethodElement;
+            if (isMethod1 == isMethod2 &&
+                executableElementInList.type ==
+                    newExecutableElementEntry.type) {
+              alreadyInList = true;
+              break;
+            }
+          }
+          if (!alreadyInList) {
+            list.add(newExecutableElementEntry);
+          }
+        }
+      }
+    }
+    return unionMap;
+  }
+
+  /**
+   * Given some array of [ExecutableElement]s, this method creates a synthetic element as
+   * described in 8.1.1:
+   *
+   * Let <i>numberOfPositionals</i>(<i>f</i>) denote the number of positional parameters of a
+   * function <i>f</i>, and let <i>numberOfRequiredParams</i>(<i>f</i>) denote the number of
+   * required parameters of a function <i>f</i>. Furthermore, let <i>s</i> denote the set of all
+   * named parameters of the <i>m<sub>1</sub>, &hellip;, m<sub>k</sub></i>. Then let
+   * * <i>h = max(numberOfPositionals(m<sub>i</sub>)),</i>
+   * * <i>r = min(numberOfRequiredParams(m<sub>i</sub>)), for all <i>i</i>, 1 <= i <= k.</i>
+   * Then <i>I</i> has a method named <i>n</i>, with <i>r</i> required parameters of type
+   * <b>dynamic</b>, <i>h</i> positional parameters of type <b>dynamic</b>, named parameters
+   * <i>s</i> of type <b>dynamic</b> and return type <b>dynamic</b>.
+   *
+   */
+  static ExecutableElement _computeMergedExecutableElement(
+      List<ExecutableElement> elementArrayToMerge) {
+    int h = _getNumOfPositionalParameters(elementArrayToMerge[0]);
+    int r = _getNumOfRequiredParameters(elementArrayToMerge[0]);
+    Set<String> namedParametersList = new HashSet<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));
+    }
+    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("", 0);
+      parameter.type = dynamicType;
+      parameter.parameterKind = ParameterKind.REQUIRED;
+      parameters[i] = parameter;
+    }
+    for (int k = 0; k < numOfPositionalParameters; k++, i++) {
+      ParameterElementImpl parameter = new ParameterElementImpl("", 0);
+      parameter.type = dynamicType;
+      parameter.parameterKind = ParameterKind.POSITIONAL;
+      parameters[i] = parameter;
+    }
+    for (int m = 0; m < namedParameters.length; m++, i++) {
+      ParameterElementImpl parameter =
+          new ParameterElementImpl(namedParameters[m], 0);
+      parameter.type = dynamicType;
+      parameter.parameterKind = ParameterKind.NAMED;
+      parameters[i] = parameter;
+    }
+    executable.returnType = dynamicType;
+    executable.parameters = parameters;
+    FunctionTypeImpl methodType = new FunctionTypeImpl(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 (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 (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);
+
+  /**
+   * Given some [ExecutableElement] returns `true` if it is an abstract member of a
+   * class.
+   *
+   * @param executableElement some [ExecutableElement] to evaluate
+   * @return `true` if the given element is an abstract member of a class
+   */
+  static bool _isAbstract(ExecutableElement executableElement) {
+    if (executableElement is MethodElement) {
+      return executableElement.isAbstract;
+    } else if (executableElement is PropertyAccessorElement) {
+      return executableElement.isAbstract;
+    }
+    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 const INIT_STATE NOT_INIT = const INIT_STATE('NOT_INIT', 0);
+
+  static const INIT_STATE INIT_IN_DECLARATION =
+      const INIT_STATE('INIT_IN_DECLARATION', 1);
+
+  static const INIT_STATE INIT_IN_FIELD_FORMAL =
+      const INIT_STATE('INIT_IN_FIELD_FORMAL', 2);
+
+  static const INIT_STATE INIT_IN_INITIALIZERS =
+      const INIT_STATE('INIT_IN_INITIALIZERS', 3);
+
+  static const List<INIT_STATE> values = const [
+    NOT_INIT,
+    INIT_IN_DECLARATION,
+    INIT_IN_FIELD_FORMAL,
+    INIT_IN_INITIALIZERS
+  ];
+
+  const INIT_STATE(String name, int ordinal) : super(name, ordinal);
+}
+
+/**
+ * Instances of the class `LabelScope` represent a scope in which a single label is defined.
+ */
+class LabelScope {
+  /**
+   * The label scope enclosing this label scope.
+   */
+  final LabelScope _outerScope;
+
+  /**
+   * The label defined in this scope.
+   */
+  final String _label;
+
+  /**
+   * The element to which the label resolves.
+   */
+  final LabelElement element;
+
+  /**
+   * The AST node to which the label resolves.
+   */
+  final AstNode node;
+
+  /**
+   * Initialize a newly created scope to represent the label [_label].
+   * [_outerScope] is the scope enclosing the new label scope.  [node] is the
+   * AST node the label resolves to.  [element] is the element the label
+   * resolves to.
+   */
+  LabelScope(this._outerScope, this._label, this.node, this.element);
+
+  /**
+   * Return the LabelScope which defines [targetLabel], or `null` if it is not
+   * defined in this scope.
+   */
+  LabelScope lookup(String targetLabel) {
+    if (_label == targetLabel) {
+      return this;
+    } else if (_outerScope != null) {
+      return _outerScope.lookup(targetLabel);
+    } else {
+      return null;
+    }
+  }
+}
+
+/**
+ * Instances of the class `Library` represent the data about a single library during the
+ * resolution of some (possibly different) library. They are not intended to be used except during
+ * the resolution process.
+ */
+class Library {
+  /**
+   * An empty list that can be used to initialize lists of libraries.
+   */
+  static const List<Library> _EMPTY_ARRAY = const <Library>[];
+
+  /**
+   * The prefix of a URI using the dart-ext scheme to reference a native code library.
+   */
+  static String _DART_EXT_SCHEME = "dart-ext:";
+
+  /**
+   * The analysis context in which this library is being analyzed.
+   */
+  final InternalAnalysisContext _analysisContext;
+
+  /**
+   * The inheritance manager which is used for this member lookups in this library.
+   */
+  InheritanceManager _inheritanceManager;
+
+  /**
+   * The listener to which analysis errors will be reported.
+   */
+  final AnalysisErrorListener errorListener;
+
+  /**
+   * The source specifying the defining compilation unit of this library.
+   */
+  final Source librarySource;
+
+  /**
+   * The library element representing this library.
+   */
+  LibraryElementImpl _libraryElement;
+
+  /**
+   * A list containing all of the libraries that are imported into this library.
+   */
+  List<Library> _importedLibraries = _EMPTY_ARRAY;
+
+  /**
+   * A table mapping URI-based directive to the actual URI value.
+   */
+  HashMap<UriBasedDirective, String> _directiveUris =
+      new HashMap<UriBasedDirective, String>();
+
+  /**
+   * A flag indicating whether this library explicitly imports core.
+   */
+  bool explicitlyImportsCore = false;
+
+  /**
+   * A list containing all of the libraries that are exported from this library.
+   */
+  List<Library> _exportedLibraries = _EMPTY_ARRAY;
+
+  /**
+   * A table mapping the sources for the compilation units in this library to their corresponding
+   * AST structures.
+   */
+  HashMap<Source, CompilationUnit> _astMap =
+      new HashMap<Source, CompilationUnit>();
+
+  /**
+   * The library scope used when resolving elements within this library's compilation units.
+   */
+  LibraryScope _libraryScope;
+
+  /**
+   * Initialize a newly created data holder that can maintain the data associated with a library.
+   *
+   * @param analysisContext the analysis context in which this library is being analyzed
+   * @param errorListener the listener to which analysis errors will be reported
+   * @param librarySource the source specifying the defining compilation unit of this library
+   */
+  Library(this._analysisContext, this.errorListener, this.librarySource) {
+    this._libraryElement =
+        _analysisContext.getLibraryElement(librarySource) as LibraryElementImpl;
+  }
+
+  /**
+   * Return an array of the [CompilationUnit]s that make up the library. The first unit is
+   * always the defining unit.
+   *
+   * @return an array of the [CompilationUnit]s that make up the library. The first unit is
+   *         always the defining unit
+   */
+  List<CompilationUnit> get compilationUnits {
+    List<CompilationUnit> unitArrayList = new List<CompilationUnit>();
+    unitArrayList.add(definingCompilationUnit);
+    for (Source source in _astMap.keys.toSet()) {
+      if (librarySource != source) {
+        unitArrayList.add(getAST(source));
+      }
+    }
+    return unitArrayList;
+  }
+
+  /**
+   * Return a collection containing the sources for the compilation units in this library, including
+   * the defining compilation unit.
+   *
+   * @return the sources for the compilation units in this library
+   */
+  Set<Source> get compilationUnitSources => _astMap.keys.toSet();
+
+  /**
+   * Return the AST structure associated with the defining compilation unit for this library.
+   *
+   * @return the AST structure associated with the defining compilation unit for this library
+   * @throws AnalysisException if an AST structure could not be created for the defining compilation
+   *           unit
+   */
+  CompilationUnit get definingCompilationUnit => getAST(librarySource);
+
+  /**
+   * Set the libraries that are exported by this library to be those in the given array.
+   *
+   * @param exportedLibraries the libraries that are exported by this library
+   */
+  void set exportedLibraries(List<Library> exportedLibraries) {
+    this._exportedLibraries = exportedLibraries;
+  }
+
+  /**
+   * Return an array containing the libraries that are exported from this library.
+   *
+   * @return an array containing the libraries that are exported from this library
+   */
+  List<Library> get exports => _exportedLibraries;
+
+  /**
+   * Set the libraries that are imported into this library to be those in the given array.
+   *
+   * @param importedLibraries the libraries that are imported into this library
+   */
+  void set importedLibraries(List<Library> importedLibraries) {
+    this._importedLibraries = importedLibraries;
+  }
+
+  /**
+   * Return an array containing the libraries that are imported into this library.
+   *
+   * @return an array containing the libraries that are imported into this library
+   */
+  List<Library> get imports => _importedLibraries;
+
+  /**
+   * Return an array containing the libraries that are either imported or exported from this
+   * library.
+   *
+   * @return the libraries that are either imported or exported from this library
+   */
+  List<Library> get importsAndExports {
+    HashSet<Library> libraries = new HashSet<Library>();
+    for (Library library in _importedLibraries) {
+      libraries.add(library);
+    }
+    for (Library library in _exportedLibraries) {
+      libraries.add(library);
+    }
+    return new List.from(libraries);
+  }
+
+  /**
+   * Return the inheritance manager for this library.
+   *
+   * @return the inheritance manager for this library
+   */
+  InheritanceManager get inheritanceManager {
+    if (_inheritanceManager == null) {
+      return _inheritanceManager = new InheritanceManager(_libraryElement);
+    }
+    return _inheritanceManager;
+  }
+
+  /**
+   * Return the library element representing this library, creating it if necessary.
+   *
+   * @return the library element representing this library
+   */
+  LibraryElementImpl get libraryElement {
+    if (_libraryElement == null) {
+      try {
+        _libraryElement = _analysisContext.computeLibraryElement(librarySource)
+            as LibraryElementImpl;
+      } on AnalysisException catch (exception, stackTrace) {
+        AnalysisEngine.instance.logger.logError(
+            "Could not compute library element for ${librarySource.fullName}",
+            new CaughtException(exception, stackTrace));
+      }
+    }
+    return _libraryElement;
+  }
+
+  /**
+   * Set the library element representing this library to the given library element.
+   *
+   * @param libraryElement the library element representing this library
+   */
+  void set libraryElement(LibraryElementImpl libraryElement) {
+    this._libraryElement = libraryElement;
+    if (_inheritanceManager != null) {
+      _inheritanceManager.libraryElement = libraryElement;
+    }
+  }
+
+  /**
+   * Return the library scope used when resolving elements within this library's compilation units.
+   *
+   * @return the library scope used when resolving elements within this library's compilation units
+   */
+  LibraryScope get libraryScope {
+    if (_libraryScope == null) {
+      _libraryScope = new LibraryScope(_libraryElement, errorListener);
+    }
+    return _libraryScope;
+  }
+
+  /**
+   * Return the AST structure associated with the given source.
+   *
+   * @param source the source representing the compilation unit whose AST is to be returned
+   * @return the AST structure associated with the given source
+   * @throws AnalysisException if an AST structure could not be created for the compilation unit
+   */
+  CompilationUnit getAST(Source source) {
+    CompilationUnit unit = _astMap[source];
+    if (unit == null) {
+      unit = _analysisContext.computeResolvableCompilationUnit(source);
+      _astMap[source] = unit;
+    }
+    return unit;
+  }
+
+  /**
+   * Return the result of resolving the URI of the given URI-based directive against the URI of the
+   * library, or `null` if the URI is not valid. If the URI is not valid, report the error.
+   *
+   * @param directive the directive which URI should be resolved
+   * @return the result of resolving the URI against the URI of the library
+   */
+  Source getSource(UriBasedDirective directive) {
+    StringLiteral uriLiteral = directive.uri;
+    if (uriLiteral is StringInterpolation) {
+      errorListener.onError(new AnalysisError(librarySource, uriLiteral.offset,
+          uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION));
+      return null;
+    }
+    String uriContent = uriLiteral.stringValue.trim();
+    _directiveUris[directive] = uriContent;
+    uriContent = Uri.encodeFull(uriContent);
+    if (directive is ImportDirective &&
+        uriContent.startsWith(_DART_EXT_SCHEME)) {
+      _libraryElement.hasExtUri = true;
+      return null;
+    }
+    try {
+      parseUriWithException(uriContent);
+      Source source =
+          _analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
+      if (!_analysisContext.exists(source)) {
+        errorListener.onError(new AnalysisError(
+            librarySource,
+            uriLiteral.offset,
+            uriLiteral.length,
+            CompileTimeErrorCode.URI_DOES_NOT_EXIST,
+            [uriContent]));
+      }
+      return source;
+    } on URISyntaxException {
+      errorListener.onError(new AnalysisError(librarySource, uriLiteral.offset,
+          uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
+    }
+    return null;
+  }
+
+  /**
+   * Returns the URI value of the given directive.
+   */
+  String getUri(UriBasedDirective directive) => _directiveUris[directive];
+
+  /**
+   * Set the AST structure associated with the defining compilation unit for this library to the
+   * given AST structure.
+   *
+   * @param unit the AST structure associated with the defining compilation unit for this library
+   */
+  void setDefiningCompilationUnit(CompilationUnit unit) {
+    _astMap[librarySource] = unit;
+  }
+
+  @override
+  String toString() => librarySource.shortName;
+}
+
+/**
+ * Instances of the class `LibraryElementBuilder` build an element model for a single library.
+ */
+class LibraryElementBuilder {
+  /**
+   * The analysis context in which the element model will be built.
+   */
+  final InternalAnalysisContext _analysisContext;
+
+  /**
+   * The listener to which errors will be reported.
+   */
+  final AnalysisErrorListener _errorListener;
+
+  /**
+   * Initialize a newly created library element builder.
+   *
+   * @param analysisContext the analysis context in which the element model will be built
+   * @param errorListener the listener to which errors will be reported
+   */
+  LibraryElementBuilder(this._analysisContext, this._errorListener);
+
+  /**
+   * Build the library element for the given library.
+   *
+   * @param library the library for which an element model is to be built
+   * @return the library element that was built
+   * @throws AnalysisException if the analysis could not be performed
+   */
+  LibraryElementImpl buildLibrary(Library library) {
+    CompilationUnitBuilder builder = new CompilationUnitBuilder();
+    Source librarySource = library.librarySource;
+    CompilationUnit definingCompilationUnit = library.definingCompilationUnit;
+    CompilationUnitElementImpl definingCompilationUnitElement = builder
+        .buildCompilationUnit(
+            librarySource, definingCompilationUnit, librarySource);
+    NodeList<Directive> directives = definingCompilationUnit.directives;
+    LibraryIdentifier libraryNameNode = null;
+    bool hasPartDirective = false;
+    FunctionElement entryPoint =
+        _findEntryPoint(definingCompilationUnitElement);
+    List<Directive> directivesToResolve = new List<Directive>();
+    List<CompilationUnitElementImpl> sourcedCompilationUnits =
+        new List<CompilationUnitElementImpl>();
+    for (Directive directive in directives) {
+      //
+      // We do not build the elements representing the import and export
+      // directives at this point. That is not done until we get to
+      // LibraryResolver.buildDirectiveModels() because we need the
+      // LibraryElements for the referenced libraries, which might not exist at
+      // this point (due to the possibility of circular references).
+      //
+      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 = partDirective.source;
+        if (_analysisContext.exists(partSource)) {
+          hasPartDirective = true;
+          CompilationUnit partUnit = library.getAST(partSource);
+          CompilationUnitElementImpl part =
+              builder.buildCompilationUnit(partSource, partUnit, librarySource);
+          part.uriOffset = partUri.offset;
+          part.uriEnd = partUri.end;
+          part.uri = partDirective.uriContent;
+          //
+          // Validate that the part contains a part-of directive with the same
+          // name as the library.
+          //
+          String partLibraryName =
+              _getPartLibraryName(partSource, partUnit, directivesToResolve);
+          if (partLibraryName == null) {
+            _errorListener.onError(new AnalysisError(
+                librarySource,
+                partUri.offset,
+                partUri.length,
+                CompileTimeErrorCode.PART_OF_NON_PART,
+                [partUri.toSource()]));
+          } else if (libraryNameNode == null) {
+            // TODO(brianwilkerson) Collect the names declared by the part.
+            // If they are all the same then we can use that name as the
+            // inferred name of the library and present it in a quick-fix.
+            // partLibraryNames.add(partLibraryName);
+          } else if (libraryNameNode.name != partLibraryName) {
+            _errorListener.onError(new AnalysisError(
+                librarySource,
+                partUri.offset,
+                partUri.length,
+                StaticWarningCode.PART_OF_DIFFERENT_LIBRARY,
+                [libraryNameNode.name, partLibraryName]));
+          }
+          if (entryPoint == null) {
+            entryPoint = _findEntryPoint(part);
+          }
+          directive.element = part;
+          sourcedCompilationUnits.add(part);
+        }
+      }
+    }
+    if (hasPartDirective && libraryNameNode == null) {
+      _errorListener.onError(new AnalysisError(librarySource, 0, 0,
+          ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART));
+    }
+    //
+    // Create and populate the library element.
+    //
+    LibraryElementImpl libraryElement = new LibraryElementImpl.forNode(
+        _analysisContext.getContextFor(librarySource), libraryNameNode);
+    libraryElement.definingCompilationUnit = definingCompilationUnitElement;
+    if (entryPoint != null) {
+      libraryElement.entryPoint = entryPoint;
+    }
+    int sourcedUnitCount = sourcedCompilationUnits.length;
+    libraryElement.parts = sourcedCompilationUnits;
+    for (Directive directive in directivesToResolve) {
+      directive.element = libraryElement;
+    }
+    library.libraryElement = libraryElement;
+    if (sourcedUnitCount > 0) {
+      _patchTopLevelAccessors(libraryElement);
+    }
+    return libraryElement;
+  }
+
+  /**
+   * Build the library element for the given library.  The resulting element is
+   * stored in the [ResolvableLibrary] structure.
+   *
+   * @param library the library for which an element model is to be built
+   * @throws AnalysisException if the analysis could not be performed
+   */
+  void buildLibrary2(ResolvableLibrary library) {
+    CompilationUnitBuilder builder = new CompilationUnitBuilder();
+    Source librarySource = library.librarySource;
+    CompilationUnit definingCompilationUnit = library.definingCompilationUnit;
+    CompilationUnitElementImpl definingCompilationUnitElement = builder
+        .buildCompilationUnit(
+            librarySource, definingCompilationUnit, librarySource);
+    NodeList<Directive> directives = definingCompilationUnit.directives;
+    LibraryIdentifier libraryNameNode = null;
+    bool hasPartDirective = false;
+    FunctionElement entryPoint =
+        _findEntryPoint(definingCompilationUnitElement);
+    List<Directive> directivesToResolve = new List<Directive>();
+    List<CompilationUnitElementImpl> sourcedCompilationUnits =
+        new List<CompilationUnitElementImpl>();
+    for (Directive directive in directives) {
+      //
+      // We do not build the elements representing the import and export
+      // directives at this point. That is not done until we get to
+      // LibraryResolver.buildDirectiveModels() because we need the
+      // LibraryElements for the referenced libraries, which might not exist at
+      // this point (due to the possibility of circular references).
+      //
+      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 = partDirective.source;
+        if (_analysisContext.exists(partSource)) {
+          hasPartDirective = true;
+          CompilationUnit partUnit = library.getAST(partSource);
+          if (partUnit != null) {
+            CompilationUnitElementImpl part = builder.buildCompilationUnit(
+                partSource, partUnit, librarySource);
+            part.uriOffset = partUri.offset;
+            part.uriEnd = partUri.end;
+            part.uri = partDirective.uriContent;
+            //
+            // Validate that the part contains a part-of directive with the same
+            // name as the library.
+            //
+            String partLibraryName =
+                _getPartLibraryName(partSource, partUnit, directivesToResolve);
+            if (partLibraryName == null) {
+              _errorListener.onError(new AnalysisError(
+                  librarySource,
+                  partUri.offset,
+                  partUri.length,
+                  CompileTimeErrorCode.PART_OF_NON_PART,
+                  [partUri.toSource()]));
+            } else if (libraryNameNode == null) {
+              // TODO(brianwilkerson) Collect the names declared by the part.
+              // If they are all the same then we can use that name as the
+              // inferred name of the library and present it in a quick-fix.
+              // partLibraryNames.add(partLibraryName);
+            } else if (libraryNameNode.name != partLibraryName) {
+              _errorListener.onError(new AnalysisError(
+                  librarySource,
+                  partUri.offset,
+                  partUri.length,
+                  StaticWarningCode.PART_OF_DIFFERENT_LIBRARY,
+                  [libraryNameNode.name, partLibraryName]));
+            }
+            if (entryPoint == null) {
+              entryPoint = _findEntryPoint(part);
+            }
+            directive.element = part;
+            sourcedCompilationUnits.add(part);
+          }
+        }
+      }
+    }
+    if (hasPartDirective && libraryNameNode == null) {
+      _errorListener.onError(new AnalysisError(librarySource, 0, 0,
+          ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART));
+    }
+    //
+    // Create and populate the library element.
+    //
+    LibraryElementImpl libraryElement = new LibraryElementImpl.forNode(
+        _analysisContext.getContextFor(librarySource), libraryNameNode);
+    libraryElement.definingCompilationUnit = definingCompilationUnitElement;
+    if (entryPoint != null) {
+      libraryElement.entryPoint = entryPoint;
+    }
+    int sourcedUnitCount = sourcedCompilationUnits.length;
+    libraryElement.parts = sourcedCompilationUnits;
+    for (Directive directive in directivesToResolve) {
+      directive.element = libraryElement;
+    }
+    library.libraryElement = libraryElement;
+    if (sourcedUnitCount > 0) {
+      _patchTopLevelAccessors(libraryElement);
+    }
+  }
+
+  /**
+   * Add all of the non-synthetic getters and setters defined in the given compilation unit that
+   * have no corresponding accessor to one of the given collections.
+   *
+   * @param getters the map to which getters are to be added
+   * @param setters the list to which setters are to be added
+   * @param unit the compilation unit defining the accessors that are potentially being added
+   */
+  void _collectAccessors(HashMap<String, PropertyAccessorElement> getters,
+      List<PropertyAccessorElement> setters, CompilationUnitElement unit) {
+    for (PropertyAccessorElement accessor in unit.accessors) {
+      if (accessor.isGetter) {
+        if (!accessor.isSynthetic && accessor.correspondingSetter == null) {
+          getters[accessor.displayName] = accessor;
+        }
+      } else {
+        if (!accessor.isSynthetic && accessor.correspondingGetter == null) {
+          setters.add(accessor);
+        }
+      }
+    }
+  }
+
+  /**
+   * 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.isEntryPoint) {
+        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.
+   *
+   * @param partSource the source representing the part
+   * @param partUnit the AST structure of the part
+   * @param directivesToResolve a list of directives that should be resolved to the library being
+   *          built
+   * @return the name of the library that the given part is declared to be a part of
+   */
+  String _getPartLibraryName(Source partSource, CompilationUnit partUnit,
+      List<Directive> directivesToResolve) {
+    for (Directive directive in partUnit.directives) {
+      if (directive is PartOfDirective) {
+        directivesToResolve.add(directive);
+        LibraryIdentifier libraryName = directive.libraryName;
+        if (libraryName != null) {
+          return libraryName.name;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Look through all of the compilation units defined for the given library, looking for getters
+   * and setters that are defined in different compilation units but that have the same names. If
+   * any are found, make sure that they have the same variable element.
+   *
+   * @param libraryElement the library defining the compilation units to be processed
+   */
+  void _patchTopLevelAccessors(LibraryElementImpl libraryElement) {
+    HashMap<String, PropertyAccessorElement> getters =
+        new HashMap<String, PropertyAccessorElement>();
+    List<PropertyAccessorElement> setters = new List<PropertyAccessorElement>();
+    _collectAccessors(getters, setters, libraryElement.definingCompilationUnit);
+    for (CompilationUnitElement unit in libraryElement.parts) {
+      _collectAccessors(getters, setters, unit);
+    }
+    for (PropertyAccessorElement setter in setters) {
+      PropertyAccessorElement getter = getters[setter.displayName];
+      if (getter != null) {
+        PropertyInducingElementImpl variable =
+            getter.variable as PropertyInducingElementImpl;
+        variable.setter = setter;
+        (setter as PropertyAccessorElementImpl).variable = variable;
+      }
+    }
+  }
+}
+
+/**
+ * Instances of the class `LibraryImportScope` represent the scope containing all of the names
+ * available from imported libraries.
+ */
+class LibraryImportScope extends Scope {
+  /**
+   * The element representing the library in which this scope is enclosed.
+   */
+  final LibraryElement _definingLibrary;
+
+  /**
+   * The listener that is to be informed when an error is encountered.
+   */
+  final AnalysisErrorListener errorListener;
+
+  /**
+   * A list of the namespaces representing the names that are available in this scope from imported
+   * libraries.
+   */
+  List<Namespace> _importedNamespaces;
+
+  /**
+   * Initialize a newly created scope representing the names imported into the given library.
+   *
+   * @param definingLibrary the element representing the library that imports the names defined in
+   *          this scope
+   * @param errorListener the listener that is to be informed when an error is encountered
+   */
+  LibraryImportScope(this._definingLibrary, this.errorListener) {
+    _createImportedNamespaces();
+  }
+
+  @override
+  void define(Element element) {
+    if (!Scope.isPrivateName(element.displayName)) {
+      super.define(element);
+    }
+  }
+
+  @override
+  Source getSource(AstNode node) {
+    Source source = super.getSource(node);
+    if (source == null) {
+      source = _definingLibrary.definingCompilationUnit.source;
+    }
+    return source;
+  }
+
+  @override
+  Element internalLookup(
+      Identifier identifier, String name, LibraryElement referencingLibrary) {
+    Element foundElement = localLookup(name, referencingLibrary);
+    if (foundElement != null) {
+      return foundElement;
+    }
+    for (int i = 0; i < _importedNamespaces.length; i++) {
+      Namespace nameSpace = _importedNamespaces[i];
+      Element element = nameSpace.get(name);
+      if (element != null) {
+        if (foundElement == null) {
+          foundElement = element;
+        } else if (!identical(foundElement, element)) {
+          foundElement = MultiplyDefinedElementImpl.fromElements(
+              _definingLibrary.context, foundElement, element);
+        }
+      }
+    }
+    if (foundElement is MultiplyDefinedElementImpl) {
+      foundElement = _removeSdkElements(
+          identifier, name, foundElement as MultiplyDefinedElementImpl);
+    }
+    if (foundElement is MultiplyDefinedElementImpl) {
+      String foundEltName = foundElement.displayName;
+      List<Element> conflictingMembers = foundElement.conflictingElements;
+      int count = conflictingMembers.length;
+      List<String> libraryNames = new List<String>(count);
+      for (int i = 0; i < count; i++) {
+        libraryNames[i] = _getLibraryName(conflictingMembers[i]);
+      }
+      libraryNames.sort();
+      errorListener.onError(new AnalysisError(
+          getSource(identifier),
+          identifier.offset,
+          identifier.length,
+          StaticWarningCode.AMBIGUOUS_IMPORT, [
+        foundEltName,
+        StringUtilities.printListOfQuotedNames(libraryNames)
+      ]));
+      return foundElement;
+    }
+    if (foundElement != null) {
+      defineNameWithoutChecking(name, foundElement);
+    }
+    return foundElement;
+  }
+
+  /**
+   * Create all of the namespaces associated with the libraries imported into this library. The
+   * names are not added to this scope, but are stored for later reference.
+   *
+   * @param definingLibrary the element representing the library that imports the libraries for
+   *          which namespaces will be created
+   */
+  void _createImportedNamespaces() {
+    NamespaceBuilder builder = new NamespaceBuilder();
+    List<ImportElement> imports = _definingLibrary.imports;
+    int count = imports.length;
+    _importedNamespaces = new List<Namespace>(count);
+    for (int i = 0; i < count; i++) {
+      _importedNamespaces[i] =
+          builder.createImportNamespaceForDirective(imports[i]);
+    }
+  }
+
+  /**
+   * Returns the name of the library that defines given element.
+   *
+   * @param element the element to get library name
+   * @return the name of the library that defines given element
+   */
+  String _getLibraryName(Element element) {
+    if (element == null) {
+      return StringUtilities.EMPTY;
+    }
+    LibraryElement library = element.library;
+    if (library == null) {
+      return StringUtilities.EMPTY;
+    }
+    List<ImportElement> imports = _definingLibrary.imports;
+    int count = imports.length;
+    for (int i = 0; i < count; i++) {
+      if (identical(imports[i].importedLibrary, library)) {
+        return library.definingCompilationUnit.displayName;
+      }
+    }
+    List<String> indirectSources = new List<String>();
+    for (int i = 0; i < count; i++) {
+      LibraryElement importedLibrary = imports[i].importedLibrary;
+      if (importedLibrary != null) {
+        for (LibraryElement exportedLibrary
+            in importedLibrary.exportedLibraries) {
+          if (identical(exportedLibrary, library)) {
+            indirectSources
+                .add(importedLibrary.definingCompilationUnit.displayName);
+          }
+        }
+      }
+    }
+    int indirectCount = indirectSources.length;
+    StringBuffer buffer = new StringBuffer();
+    buffer.write(library.definingCompilationUnit.displayName);
+    if (indirectCount > 0) {
+      buffer.write(" (via ");
+      if (indirectCount > 1) {
+        indirectSources.sort();
+        buffer.write(StringUtilities.printListOfQuotedNames(indirectSources));
+      } else {
+        buffer.write(indirectSources[0]);
+      }
+      buffer.write(")");
+    }
+    return buffer.toString();
+  }
+
+  /**
+   * Given a collection of elements (captured by the [foundElement]) that the
+   * [identifier] (with the given [name]) resolved to, remove from the list all
+   * of the names defined in the SDK and return the element(s) that remain.
+   */
+  Element _removeSdkElements(Identifier identifier, String name,
+      MultiplyDefinedElementImpl foundElement) {
+    List<Element> conflictingElements = foundElement.conflictingElements;
+    List<Element> nonSdkElements = new List<Element>();
+    Element sdkElement = null;
+    for (Element member in conflictingElements) {
+      if (member.library.isInSdk) {
+        sdkElement = member;
+      } else {
+        nonSdkElements.add(member);
+      }
+    }
+    if (sdkElement != null && nonSdkElements.length > 0) {
+      String sdkLibName = _getLibraryName(sdkElement);
+      String otherLibName = _getLibraryName(nonSdkElements[0]);
+      errorListener.onError(new AnalysisError(
+          getSource(identifier),
+          identifier.offset,
+          identifier.length,
+          StaticWarningCode.CONFLICTING_DART_IMPORT,
+          [name, sdkLibName, otherLibName]));
+    }
+    if (nonSdkElements.length == conflictingElements.length) {
+      // None of the members were removed
+      return foundElement;
+    } else if (nonSdkElements.length == 1) {
+      // All but one member was removed
+      return nonSdkElements[0];
+    } else if (nonSdkElements.length == 0) {
+      // All members were removed
+      AnalysisEngine.instance.logger
+          .logInformation("Multiply defined SDK element: $foundElement");
+      return foundElement;
+    }
+    return new MultiplyDefinedElementImpl(
+        _definingLibrary.context, nonSdkElements);
+  }
+}
+
+/**
+ * Instances of the class `LibraryResolver` are used to resolve one or more mutually dependent
+ * libraries within a single context.
+ */
+class LibraryResolver {
+  /**
+   * The analysis context in which the libraries are being analyzed.
+   */
+  final InternalAnalysisContext analysisContext;
+
+  /**
+   * The listener to which analysis errors will be reported, this error listener is either
+   * references [recordingErrorListener], or it unions the passed
+   * [AnalysisErrorListener] with the [recordingErrorListener].
+   */
+  RecordingErrorListener _errorListener;
+
+  /**
+   * A source object representing the core library (dart:core).
+   */
+  Source _coreLibrarySource;
+
+  /**
+   * A Source object representing the async library (dart:async).
+   */
+  Source _asyncLibrarySource;
+
+  /**
+   * The object representing the core library.
+   */
+  Library _coreLibrary;
+
+  /**
+   * The object representing the async library.
+   */
+  Library _asyncLibrary;
+
+  /**
+   * The object used to access the types from the core library.
+   */
+  TypeProvider _typeProvider;
+
+  /**
+   * A table mapping library sources to the information being maintained for those libraries.
+   */
+  HashMap<Source, Library> _libraryMap = new HashMap<Source, Library>();
+
+  /**
+   * A collection containing the libraries that are being resolved together.
+   */
+  Set<Library> _librariesInCycles;
+
+  /**
+   * Initialize a newly created library resolver to resolve libraries within the given context.
+   *
+   * @param analysisContext the analysis context in which the library is being analyzed
+   */
+  LibraryResolver(this.analysisContext) {
+    this._errorListener = new RecordingErrorListener();
+    _coreLibrarySource =
+        analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
+    _asyncLibrarySource =
+        analysisContext.sourceFactory.forUri(DartSdk.DART_ASYNC);
+  }
+
+  /**
+   * Return the listener to which analysis errors will be reported.
+   *
+   * @return the listener to which analysis errors will be reported
+   */
+  RecordingErrorListener get errorListener => _errorListener;
+
+  /**
+   * Return an array containing information about all of the libraries that were resolved.
+   *
+   * @return an array containing the libraries that were resolved
+   */
+  Set<Library> get resolvedLibraries => _librariesInCycles;
+
+  /**
+   * The object used to access the types from the core library.
+   */
+  TypeProvider get typeProvider => _typeProvider;
+
+  /**
+   * 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);
+    _libraryMap[librarySource] = library;
+    return library;
+  }
+
+  /**
+   * Resolve the library specified by the given source in the given context. The library is assumed
+   * to be embedded in the given source.
+   *
+   * @param librarySource the source specifying the defining compilation unit of the library to be
+   *          resolved
+   * @param unit the compilation unit representing the embedded library
+   * @param fullAnalysis `true` if a full analysis should be performed
+   * @return the element representing the resolved library
+   * @throws AnalysisException if the library could not be resolved for some reason
+   */
+  LibraryElement resolveEmbeddedLibrary(
+      Source librarySource, CompilationUnit unit, bool fullAnalysis) {
+    //
+    // Create the objects representing the library being resolved and the core
+    // library.
+    //
+    Library targetLibrary = _createLibraryWithUnit(librarySource, unit);
+    _coreLibrary = _libraryMap[_coreLibrarySource];
+    if (_coreLibrary == null) {
+      // This will only happen if the library being analyzed is the core
+      // library.
+      _coreLibrary = createLibrary(_coreLibrarySource);
+      if (_coreLibrary == null) {
+        LibraryResolver2.missingCoreLibrary(
+            analysisContext, _coreLibrarySource);
+      }
+    }
+    _asyncLibrary = _libraryMap[_asyncLibrarySource];
+    if (_asyncLibrary == null) {
+      // This will only happen if the library being analyzed is the async
+      // library.
+      _asyncLibrary = createLibrary(_asyncLibrarySource);
+      if (_asyncLibrary == null) {
+        LibraryResolver2.missingAsyncLibrary(
+            analysisContext, _asyncLibrarySource);
+      }
+    }
+    //
+    // Compute the set of libraries that need to be resolved together.
+    //
+    _computeEmbeddedLibraryDependencies(targetLibrary, unit);
+    _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
+    //
+    // Build the element models representing the libraries being resolved.
+    // This is done in three steps:
+    //
+    // 1. Build the basic element models without making any connections
+    //    between elements other than the basic parent/child relationships.
+    //    This includes building the elements representing the libraries.
+    // 2. Build the elements for the import and export directives. This
+    //    requires that we have the elements built for the referenced
+    //    libraries, but because of the possibility of circular references
+    //    needs to happen after all of the library elements have been created.
+    // 3. Build the rest of the type model by connecting superclasses, mixins,
+    //    and interfaces. This requires that we be able to compute the names
+    //    visible in the libraries being resolved, which in turn requires that
+    //    we have resolved the import directives.
+    //
+    _buildElementModels();
+    LibraryElement coreElement = _coreLibrary.libraryElement;
+    if (coreElement == null) {
+      throw new AnalysisException("Could not resolve dart:core");
+    }
+    LibraryElement asyncElement = _asyncLibrary.libraryElement;
+    if (asyncElement == null) {
+      throw new AnalysisException("Could not resolve dart:async");
+    }
+    _buildDirectiveModels();
+    _typeProvider = new TypeProviderImpl(coreElement, asyncElement);
+    _buildTypeHierarchies();
+    //
+    // Perform resolution and type analysis.
+    //
+    // TODO(brianwilkerson) Decide whether we want to resolve all of the
+    // libraries or whether we want to only resolve the target library.
+    // The advantage to resolving everything is that we have already done part
+    // of the work so we'll avoid duplicated effort. The disadvantage of
+    // resolving everything is that we might do extra work that we don't
+    // really care about. Another possibility is to add a parameter to this
+    // method and punt the decision to the clients.
+    //
+    //if (analyzeAll) {
+    resolveReferencesAndTypes();
+    //} else {
+    //  resolveReferencesAndTypes(targetLibrary);
+    //}
+    _performConstantEvaluation();
+    return targetLibrary.libraryElement;
+  }
+
+  /**
+   * Resolve the library specified by the given source in the given context.
+   *
+   * Note that because Dart allows circular imports between libraries, it is possible that more than
+   * one library will need to be resolved. In such cases the error listener can receive errors from
+   * multiple libraries.
+   *
+   * @param librarySource the source specifying the defining compilation unit of the library to be
+   *          resolved
+   * @param fullAnalysis `true` if a full analysis should be performed
+   * @return the element representing the resolved library
+   * @throws AnalysisException if the library could not be resolved for some reason
+   */
+  LibraryElement resolveLibrary(Source librarySource, bool fullAnalysis) {
+    //
+    // Create the object representing the library being resolved and compute
+    // the dependency relationship.  Note that all libraries depend implicitly
+    // on core, and we inject an ersatz dependency on async, so once this is
+    // done the core and async library elements will have been created.
+    //
+    Library targetLibrary = createLibrary(librarySource);
+    _computeLibraryDependencies(targetLibrary);
+    _coreLibrary = _libraryMap[_coreLibrarySource];
+    _asyncLibrary = _libraryMap[_asyncLibrarySource];
+    //
+    // Compute the set of libraries that need to be resolved together.
+    //
+    _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
+    //
+    // Build the element models representing the libraries being resolved.
+    // This is done in three steps:
+    //
+    // 1. Build the basic element models without making any connections
+    //    between elements other than the basic parent/child relationships.
+    //    This includes building the elements representing the libraries, but
+    //    excludes members defined in enums.
+    // 2. Build the elements for the import and export directives. This
+    //    requires that we have the elements built for the referenced
+    //    libraries, but because of the possibility of circular references
+    //    needs to happen after all of the library elements have been created.
+    // 3. Build the members in enum declarations.
+    // 4. Build the rest of the type model by connecting superclasses, mixins,
+    //    and interfaces. This requires that we be able to compute the names
+    //    visible in the libraries being resolved, which in turn requires that
+    //    we have resolved the import directives.
+    //
+    _buildElementModels();
+    LibraryElement coreElement = _coreLibrary.libraryElement;
+    if (coreElement == null) {
+      throw new AnalysisException("Could not resolve dart:core");
+    }
+    LibraryElement asyncElement = _asyncLibrary.libraryElement;
+    if (asyncElement == null) {
+      throw new AnalysisException("Could not resolve dart:async");
+    }
+    _buildDirectiveModels();
+    _typeProvider = new TypeProviderImpl(coreElement, asyncElement);
+    _buildEnumMembers();
+    _buildTypeHierarchies();
+    //
+    // Perform resolution and type analysis.
+    //
+    // TODO(brianwilkerson) Decide whether we want to resolve all of the
+    // libraries or whether we want to only resolve the target library. The
+    // advantage to resolving everything is that we have already done part of
+    // the work so we'll avoid duplicated effort. The disadvantage of
+    // resolving everything is that we might do extra work that we don't
+    // really care about. Another possibility is to add a parameter to this
+    // method and punt the decision to the clients.
+    //
+    //if (analyzeAll) {
+    resolveReferencesAndTypes();
+    //} else {
+    //  resolveReferencesAndTypes(targetLibrary);
+    //}
+    _performConstantEvaluation();
+    return targetLibrary.libraryElement;
+  }
+
+  /**
+   * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
+   *
+   * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
+   *           libraries could not have their types analyzed
+   */
+  void resolveReferencesAndTypes() {
+    for (Library library in _librariesInCycles) {
+      _resolveReferencesAndTypesInLibrary(library);
+    }
+  }
+
+  /**
+   * Add a dependency to the given map from the referencing library to the referenced library.
+   *
+   * @param dependencyMap the map to which the dependency is to be added
+   * @param referencingLibrary the library that references the referenced library
+   * @param referencedLibrary the library referenced by the referencing library
+   */
+  void _addDependencyToMap(HashMap<Library, List<Library>> dependencyMap,
+      Library referencingLibrary, Library referencedLibrary) {
+    List<Library> dependentLibraries = dependencyMap[referencedLibrary];
+    if (dependentLibraries == null) {
+      dependentLibraries = new List<Library>();
+      dependencyMap[referencedLibrary] = dependentLibraries;
+    }
+    dependentLibraries.add(referencingLibrary);
+  }
+
+  /**
+   * Given a library that is part of a cycle that includes the root library, add to the given set of
+   * libraries all of the libraries reachable from the root library that are also included in the
+   * cycle.
+   *
+   * @param library the library to be added to the collection of libraries in cycles
+   * @param librariesInCycle a collection of the libraries that are in the cycle
+   * @param dependencyMap a table mapping libraries to the collection of libraries from which those
+   *          libraries are referenced
+   */
+  void _addLibrariesInCycle(Library library, Set<Library> librariesInCycle,
+      HashMap<Library, List<Library>> dependencyMap) {
+    if (librariesInCycle.add(library)) {
+      List<Library> dependentLibraries = dependencyMap[library];
+      if (dependentLibraries != null) {
+        for (Library dependentLibrary in dependentLibraries) {
+          _addLibrariesInCycle(
+              dependentLibrary, librariesInCycle, dependencyMap);
+        }
+      }
+    }
+  }
+
+  /**
+   * Add the given library, and all libraries reachable from it that have not already been visited,
+   * to the given dependency map.
+   *
+   * @param library the library currently being added to the dependency map
+   * @param dependencyMap the dependency map being computed
+   * @param visitedLibraries the libraries that have already been visited, used to prevent infinite
+   *          recursion
+   */
+  void _addToDependencyMap(
+      Library library,
+      HashMap<Library, List<Library>> dependencyMap,
+      Set<Library> visitedLibraries) {
+    if (visitedLibraries.add(library)) {
+      bool asyncFound = false;
+      for (Library referencedLibrary in library.importsAndExports) {
+        _addDependencyToMap(dependencyMap, library, referencedLibrary);
+        _addToDependencyMap(referencedLibrary, dependencyMap, visitedLibraries);
+        if (identical(referencedLibrary, _asyncLibrary)) {
+          asyncFound = true;
+        }
+      }
+      if (!library.explicitlyImportsCore && !identical(library, _coreLibrary)) {
+        _addDependencyToMap(dependencyMap, library, _coreLibrary);
+      }
+      if (!asyncFound && !identical(library, _asyncLibrary)) {
+        _addDependencyToMap(dependencyMap, library, _asyncLibrary);
+        _addToDependencyMap(_asyncLibrary, dependencyMap, visitedLibraries);
+      }
+    }
+  }
+
+  /**
+   * Build the element model representing the combinators declared by the given directive.
+   *
+   * @param directive the directive that declares the combinators
+   * @return an array containing the import combinators that were built
+   */
+  List<NamespaceCombinator> _buildCombinators(NamespaceDirective directive) {
+    List<NamespaceCombinator> combinators = new List<NamespaceCombinator>();
+    for (Combinator combinator in directive.combinators) {
+      if (combinator is HideCombinator) {
+        HideElementCombinatorImpl hide = new HideElementCombinatorImpl();
+        hide.hiddenNames = _getIdentifiers(combinator.hiddenNames);
+        combinators.add(hide);
+      } else {
+        ShowElementCombinatorImpl show = new ShowElementCombinatorImpl();
+        show.offset = combinator.offset;
+        show.end = combinator.end;
+        show.shownNames =
+            _getIdentifiers((combinator as ShowCombinator).shownNames);
+        combinators.add(show);
+      }
+    }
+    return combinators;
+  }
+
+  /**
+   * Every library now has a corresponding [LibraryElement], so it is now possible to resolve
+   * the import and export directives.
+   *
+   * @throws AnalysisException if the defining compilation unit for any of the libraries could not
+   *           be accessed
+   */
+  void _buildDirectiveModels() {
+    for (Library library in _librariesInCycles) {
+      HashMap<String, PrefixElementImpl> nameToPrefixMap =
+          new HashMap<String, PrefixElementImpl>();
+      List<ImportElement> imports = new List<ImportElement>();
+      List<ExportElement> exports = new List<ExportElement>();
+      for (Directive directive in library.definingCompilationUnit.directives) {
+        if (directive is ImportDirective) {
+          ImportDirective importDirective = directive;
+          String uriContent = importDirective.uriContent;
+          if (DartUriResolver.isDartExtUri(uriContent)) {
+            library.libraryElement.hasExtUri = true;
+          }
+          Source importedSource = importDirective.source;
+          if (importedSource != null) {
+            // The imported source will be null if the URI in the import
+            // directive was invalid.
+            Library importedLibrary = _libraryMap[importedSource];
+            if (importedLibrary != null) {
+              ImportElementImpl importElement =
+                  new ImportElementImpl(directive.offset);
+              StringLiteral uriLiteral = importDirective.uri;
+              importElement.uriOffset = uriLiteral.offset;
+              importElement.uriEnd = uriLiteral.end;
+              importElement.uri = uriContent;
+              importElement.deferred = importDirective.deferredKeyword != null;
+              importElement.combinators = _buildCombinators(importDirective);
+              LibraryElement importedLibraryElement =
+                  importedLibrary.libraryElement;
+              if (importedLibraryElement != null) {
+                importElement.importedLibrary = importedLibraryElement;
+              }
+              SimpleIdentifier prefixNode = directive.prefix;
+              if (prefixNode != null) {
+                importElement.prefixOffset = prefixNode.offset;
+                String prefixName = prefixNode.name;
+                PrefixElementImpl prefix = nameToPrefixMap[prefixName];
+                if (prefix == null) {
+                  prefix = new PrefixElementImpl.forNode(prefixNode);
+                  nameToPrefixMap[prefixName] = prefix;
+                }
+                importElement.prefix = prefix;
+                prefixNode.staticElement = prefix;
+              }
+              directive.element = importElement;
+              imports.add(importElement);
+              if (analysisContext.computeKindOf(importedSource) !=
+                  SourceKind.LIBRARY) {
+                ErrorCode errorCode = (importElement.isDeferred
+                    ? StaticWarningCode.IMPORT_OF_NON_LIBRARY
+                    : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
+                _errorListener.onError(new AnalysisError(
+                    library.librarySource,
+                    uriLiteral.offset,
+                    uriLiteral.length,
+                    errorCode,
+                    [uriLiteral.toSource()]));
+              }
+            }
+          }
+        } else if (directive is ExportDirective) {
+          ExportDirective exportDirective = directive;
+          Source exportedSource = exportDirective.source;
+          if (exportedSource != null) {
+            // The exported source will be null if the URI in the export
+            // directive was invalid.
+            Library exportedLibrary = _libraryMap[exportedSource];
+            if (exportedLibrary != null) {
+              ExportElementImpl exportElement =
+                  new ExportElementImpl(directive.offset);
+              StringLiteral uriLiteral = exportDirective.uri;
+              exportElement.uriOffset = uriLiteral.offset;
+              exportElement.uriEnd = uriLiteral.end;
+              exportElement.uri = exportDirective.uriContent;
+              exportElement.combinators = _buildCombinators(exportDirective);
+              LibraryElement exportedLibraryElement =
+                  exportedLibrary.libraryElement;
+              if (exportedLibraryElement != null) {
+                exportElement.exportedLibrary = exportedLibraryElement;
+              }
+              directive.element = exportElement;
+              exports.add(exportElement);
+              if (analysisContext.computeKindOf(exportedSource) !=
+                  SourceKind.LIBRARY) {
+                _errorListener.onError(new AnalysisError(
+                    library.librarySource,
+                    uriLiteral.offset,
+                    uriLiteral.length,
+                    CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY,
+                    [uriLiteral.toSource()]));
+              }
+            }
+          }
+        }
+      }
+      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 = imports;
+      libraryElement.exports = exports;
+      if (libraryElement.entryPoint == null) {
+        Namespace namespace = new NamespaceBuilder()
+            .createExportNamespaceForLibrary(libraryElement);
+        Element element = namespace.get(FunctionElement.MAIN_FUNCTION_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) {
+      LibraryElementBuilder builder =
+          new LibraryElementBuilder(analysisContext, errorListener);
+      LibraryElementImpl libraryElement = builder.buildLibrary(library);
+      library.libraryElement = libraryElement;
+    }
+  }
+
+  /**
+   * Build the members in enum declarations. This cannot be done while building the rest of the
+   * element model because it depends on being able to access core types, which cannot happen until
+   * the rest of the element model has been built (when resolving the core library).
+   *
+   * @throws AnalysisException if any of the enum members could not be built
+   */
+  void _buildEnumMembers() {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
+      for (Library library in _librariesInCycles) {
+        for (Source source in library.compilationUnitSources) {
+          EnumMemberBuilder builder = new EnumMemberBuilder(_typeProvider);
+          library.getAST(source).accept(builder);
+        }
+      }
+    });
+  }
+
+  /**
+   * Resolve the type hierarchy across all of the types declared in the libraries in the current
+   * cycle.
+   *
+   * @throws AnalysisException if any of the type hierarchies could not be resolved
+   */
+  void _buildTypeHierarchies() {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
+      for (Library library in _librariesInCycles) {
+        for (Source source in library.compilationUnitSources) {
+          TypeResolverVisitorFactory typeResolverVisitorFactory =
+              analysisContext.typeResolverVisitorFactory;
+          TypeResolverVisitor visitor = (typeResolverVisitorFactory == null)
+              ? new TypeResolverVisitor(library.libraryElement, source,
+                  _typeProvider, library.errorListener,
+                  nameScope: library.libraryScope)
+              : typeResolverVisitorFactory(library, source, _typeProvider);
+          library.getAST(source).accept(visitor);
+        }
+      }
+    });
+  }
+
+  /**
+   * Compute a dependency map of libraries reachable from the given library. A dependency map is a
+   * table that maps individual libraries to a list of the libraries that either import or export
+   * those libraries.
+   *
+   * This map is used to compute all of the libraries involved in a cycle that include the root
+   * library. Given that we only add libraries that are reachable from the root library, when we
+   * work backward we are guaranteed to only get libraries in the cycle.
+   *
+   * @param library the library currently being added to the dependency map
+   */
+  HashMap<Library, List<Library>> _computeDependencyMap(Library library) {
+    HashMap<Library, List<Library>> dependencyMap =
+        new HashMap<Library, List<Library>>();
+    _addToDependencyMap(library, dependencyMap, new HashSet<Library>());
+    return dependencyMap;
+  }
+
+  /**
+   * Recursively traverse the libraries reachable from the given library, creating instances of the
+   * class [Library] to represent them, and record the references in the library objects.
+   *
+   * @param library the library to be processed to find libraries that have not yet been traversed
+   * @throws AnalysisException if some portion of the library graph could not be traversed
+   */
+  void _computeEmbeddedLibraryDependencies(
+      Library library, CompilationUnit unit) {
+    Source librarySource = library.librarySource;
+    HashSet<Source> exportedSources = new HashSet<Source>();
+    HashSet<Source> importedSources = new HashSet<Source>();
+    for (Directive directive in unit.directives) {
+      if (directive is ExportDirective) {
+        Source exportSource = _resolveSource(librarySource, directive);
+        if (exportSource != null) {
+          exportedSources.add(exportSource);
+        }
+      } else if (directive is ImportDirective) {
+        Source importSource = _resolveSource(librarySource, directive);
+        if (importSource != null) {
+          importedSources.add(importSource);
+        }
+      }
+    }
+    _computeLibraryDependenciesFromDirectives(library,
+        new List.from(importedSources), new List.from(exportedSources));
+  }
+
+  /**
+   * Return a collection containing all of the libraries reachable from the given library that are
+   * contained in a cycle that includes the given library.
+   *
+   * @param library the library that must be included in any cycles whose members are to be returned
+   * @return all of the libraries referenced by the given library that have a circular reference
+   *         back to the given library
+   */
+  Set<Library> _computeLibrariesInCycles(Library library) {
+    HashMap<Library, List<Library>> dependencyMap =
+        _computeDependencyMap(library);
+    Set<Library> librariesInCycle = new HashSet<Library>();
+    _addLibrariesInCycle(library, librariesInCycle, dependencyMap);
+    return librariesInCycle;
+  }
+
+  /**
+   * Recursively traverse the libraries reachable from the given library, creating instances of the
+   * class [Library] to represent them, and record the references in the library objects.
+   *
+   * @param library the library to be processed to find libraries that have not yet been traversed
+   * @throws AnalysisException if some portion of the library graph could not be traversed
+   */
+  void _computeLibraryDependencies(Library library) {
+    Source librarySource = library.librarySource;
+    _computeLibraryDependenciesFromDirectives(
+        library,
+        analysisContext.computeImportedLibraries(librarySource),
+        analysisContext.computeExportedLibraries(librarySource));
+  }
+
+  /**
+   * Recursively traverse the libraries reachable from the given library, creating instances of the
+   * class [Library] to represent them, and record the references in the library objects.
+   *
+   * @param library the library to be processed to find libraries that have not yet been traversed
+   * @param importedSources an array containing the sources that are imported into the given library
+   * @param exportedSources an array containing the sources that are exported from the given library
+   * @throws AnalysisException if some portion of the library graph could not be traversed
+   */
+  void _computeLibraryDependenciesFromDirectives(Library library,
+      List<Source> importedSources, List<Source> exportedSources) {
+    List<Library> importedLibraries = new List<Library>();
+    bool explicitlyImportsCore = false;
+    bool importsAsync = false;
+    for (Source importedSource in importedSources) {
+      if (importedSource == _coreLibrarySource) {
+        explicitlyImportsCore = true;
+      }
+      if (importedSource == _asyncLibrarySource) {
+        importsAsync = true;
+      }
+      Library importedLibrary = _libraryMap[importedSource];
+      if (importedLibrary == null) {
+        importedLibrary = _createLibraryOrNull(importedSource);
+        if (importedLibrary != null) {
+          _computeLibraryDependencies(importedLibrary);
+        }
+      }
+      if (importedLibrary != null) {
+        importedLibraries.add(importedLibrary);
+      }
+    }
+    library.importedLibraries = importedLibraries;
+    List<Library> exportedLibraries = new List<Library>();
+    for (Source exportedSource in exportedSources) {
+      Library exportedLibrary = _libraryMap[exportedSource];
+      if (exportedLibrary == null) {
+        exportedLibrary = _createLibraryOrNull(exportedSource);
+        if (exportedLibrary != null) {
+          _computeLibraryDependencies(exportedLibrary);
+        }
+      }
+      if (exportedLibrary != null) {
+        exportedLibraries.add(exportedLibrary);
+      }
+    }
+    library.exportedLibraries = exportedLibraries;
+    library.explicitlyImportsCore = explicitlyImportsCore;
+    if (!explicitlyImportsCore && _coreLibrarySource != library.librarySource) {
+      Library importedLibrary = _libraryMap[_coreLibrarySource];
+      if (importedLibrary == null) {
+        importedLibrary = _createLibraryOrNull(_coreLibrarySource);
+        if (importedLibrary != null) {
+          _computeLibraryDependencies(importedLibrary);
+        }
+      }
+    }
+    if (!importsAsync && _asyncLibrarySource != library.librarySource) {
+      Library importedLibrary = _libraryMap[_asyncLibrarySource];
+      if (importedLibrary == null) {
+        importedLibrary = _createLibraryOrNull(_asyncLibrarySource);
+        if (importedLibrary != null) {
+          _computeLibraryDependencies(importedLibrary);
+        }
+      }
+    }
+  }
+
+  /**
+   * 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 (!analysisContext.exists(librarySource)) {
+      return null;
+    }
+    Library library =
+        new Library(analysisContext, _errorListener, librarySource);
+    _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 unit the compilation unit that defines the library
+   * @return the library object that was created
+   * @throws AnalysisException if the library source is not valid
+   */
+  Library _createLibraryWithUnit(Source librarySource, CompilationUnit unit) {
+    Library library =
+        new Library(analysisContext, _errorListener, librarySource);
+    library.setDefiningCompilationUnit(unit);
+    _libraryMap[librarySource] = library;
+    return library;
+  }
+
+  /**
+   * Return an array containing the lexical identifiers associated with the nodes in the given list.
+   *
+   * @param names the AST nodes representing the identifiers
+   * @return the lexical identifiers associated with the nodes in the list
+   */
+  List<String> _getIdentifiers(NodeList<SimpleIdentifier> names) {
+    int count = names.length;
+    List<String> identifiers = new List<String>(count);
+    for (int i = 0; i < count; i++) {
+      identifiers[i] = names[i].name;
+    }
+    return identifiers;
+  }
+
+  /**
+   * Compute a value for all of the constants in the libraries being analyzed.
+   */
+  void _performConstantEvaluation() {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
+      ConstantValueComputer computer = new ConstantValueComputer(
+          analysisContext, _typeProvider, analysisContext.declaredVariables);
+      for (Library library in _librariesInCycles) {
+        for (Source source in library.compilationUnitSources) {
+          try {
+            CompilationUnit unit = library.getAST(source);
+            if (unit != null) {
+              computer.add(unit, source, library.librarySource);
+            }
+          } on AnalysisException catch (exception, stackTrace) {
+            AnalysisEngine.instance.logger.logError(
+                "Internal Error: Could not access AST for ${source.fullName} during constant evaluation",
+                new CaughtException(exception, stackTrace));
+          }
+        }
+      }
+      computer.computeValues();
+      // As a temporary workaround for issue 21572, run ConstantVerifier now.
+      // TODO(paulberry): remove this workaround once issue 21572 is fixed.
+      for (Library library in _librariesInCycles) {
+        for (Source source in library.compilationUnitSources) {
+          try {
+            CompilationUnit unit = library.getAST(source);
+            ErrorReporter errorReporter =
+                new ErrorReporter(_errorListener, source);
+            ConstantVerifier constantVerifier = new ConstantVerifier(
+                errorReporter,
+                library.libraryElement,
+                _typeProvider,
+                analysisContext.declaredVariables);
+            unit.accept(constantVerifier);
+          } on AnalysisException catch (exception, stackTrace) {
+            AnalysisEngine.instance.logger.logError(
+                "Internal Error: Could not access AST for ${source.fullName} "
+                "during constant verification",
+                new CaughtException(exception, stackTrace));
+          }
+        }
+      }
+    });
+  }
+
+  /**
+   * Resolve the identifiers and perform type analysis in the given library.
+   *
+   * @param library the library to be resolved
+   * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
+   *           the library cannot be analyzed
+   */
+  void _resolveReferencesAndTypesInLibrary(Library library) {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
+      for (Source source in library.compilationUnitSources) {
+        CompilationUnit ast = library.getAST(source);
+        ast.accept(new VariableResolverVisitor(library.libraryElement, source,
+            _typeProvider, library.errorListener,
+            nameScope: library.libraryScope));
+        ResolverVisitorFactory visitorFactory =
+            analysisContext.resolverVisitorFactory;
+        ResolverVisitor visitor = visitorFactory != null
+            ? visitorFactory(library, source, _typeProvider)
+            : new ResolverVisitor(library.libraryElement, source, _typeProvider,
+                library.errorListener,
+                nameScope: library.libraryScope,
+                inheritanceManager: library.inheritanceManager);
+        ast.accept(visitor);
+      }
+    });
+  }
+
+  /**
+   * Return the result of resolving the URI of the given URI-based directive against the URI of the
+   * given library, or `null` if the URI is not valid.
+   *
+   * @param librarySource the source representing the library containing the directive
+   * @param directive the directive which URI should be resolved
+   * @return the result of resolving the URI against the URI of the library
+   */
+  Source _resolveSource(Source librarySource, UriBasedDirective directive) {
+    StringLiteral uriLiteral = directive.uri;
+    if (uriLiteral is StringInterpolation) {
+      return null;
+    }
+    String uriContent = uriLiteral.stringValue.trim();
+    if (uriContent == null || uriContent.isEmpty) {
+      return null;
+    }
+    uriContent = Uri.encodeFull(uriContent);
+    return analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
+  }
+}
+
+/**
+ * Instances of the class `LibraryResolver` are used to resolve one or more mutually dependent
+ * libraries within a single context.
+ */
+class LibraryResolver2 {
+  /**
+   * The analysis context in which the libraries are being analyzed.
+   */
+  final InternalAnalysisContext analysisContext;
+
+  /**
+   * The listener to which analysis errors will be reported, this error listener is either
+   * references [recordingErrorListener], or it unions the passed
+   * [AnalysisErrorListener] with the [recordingErrorListener].
+   */
+  RecordingErrorListener _errorListener;
+
+  /**
+   * A source object representing the core library (dart:core).
+   */
+  Source _coreLibrarySource;
+
+  /**
+   * A source object representing the async library (dart:async).
+   */
+  Source _asyncLibrarySource;
+
+  /**
+   * The object representing the core library.
+   */
+  ResolvableLibrary _coreLibrary;
+
+  /**
+   * The object representing the async library.
+   */
+  ResolvableLibrary _asyncLibrary;
+
+  /**
+   * The object used to access the types from the core library.
+   */
+  TypeProvider _typeProvider;
+
+  /**
+   * A table mapping library sources to the information being maintained for those libraries.
+   */
+  HashMap<Source, ResolvableLibrary> _libraryMap =
+      new HashMap<Source, ResolvableLibrary>();
+
+  /**
+   * A collection containing the libraries that are being resolved together.
+   */
+  List<ResolvableLibrary> _librariesInCycle;
+
+  /**
+   * Initialize a newly created library resolver to resolve libraries within the given context.
+   *
+   * @param analysisContext the analysis context in which the library is being analyzed
+   */
+  LibraryResolver2(this.analysisContext) {
+    this._errorListener = new RecordingErrorListener();
+    _coreLibrarySource =
+        analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
+    _asyncLibrarySource =
+        analysisContext.sourceFactory.forUri(DartSdk.DART_ASYNC);
+  }
+
+  /**
+   * Return the listener to which analysis errors will be reported.
+   *
+   * @return the listener to which analysis errors will be reported
+   */
+  RecordingErrorListener get errorListener => _errorListener;
+
+  /**
+   * Return an array containing information about all of the libraries that were resolved.
+   *
+   * @return an array containing the libraries that were resolved
+   */
+  List<ResolvableLibrary> get resolvedLibraries => _librariesInCycle;
+
+  /**
+   * Resolve the library specified by the given source in the given context.
+   *
+   * Note that because Dart allows circular imports between libraries, it is possible that more than
+   * one library will need to be resolved. In such cases the error listener can receive errors from
+   * multiple libraries.
+   *
+   * @param librarySource the source specifying the defining compilation unit of the library to be
+   *          resolved
+   * @param fullAnalysis `true` if a full analysis should be performed
+   * @return the element representing the resolved library
+   * @throws AnalysisException if the library could not be resolved for some reason
+   */
+  LibraryElement resolveLibrary(
+      Source librarySource, List<ResolvableLibrary> librariesInCycle) {
+    //
+    // Build the map of libraries that are known.
+    //
+    this._librariesInCycle = librariesInCycle;
+    _libraryMap = _buildLibraryMap();
+    ResolvableLibrary targetLibrary = _libraryMap[librarySource];
+    _coreLibrary = _libraryMap[_coreLibrarySource];
+    _asyncLibrary = _libraryMap[_asyncLibrarySource];
+    //
+    // Build the element models representing the libraries being resolved.
+    // This is done in three steps:
+    //
+    // 1. Build the basic element models without making any connections
+    //    between elements other than the basic parent/child relationships.
+    //    This includes building the elements representing the libraries, but
+    //    excludes members defined in enums.
+    // 2. Build the elements for the import and export directives. This
+    //    requires that we have the elements built for the referenced
+    //    libraries, but because of the possibility of circular references
+    //    needs to happen after all of the library elements have been created.
+    // 3. Build the members in enum declarations.
+    // 4. Build the rest of the type model by connecting superclasses, mixins,
+    //    and interfaces. This requires that we be able to compute the names
+    //    visible in the libraries being resolved, which in turn requires that
+    //    we have resolved the import directives.
+    //
+    _buildElementModels();
+    LibraryElement coreElement = _coreLibrary.libraryElement;
+    if (coreElement == null) {
+      missingCoreLibrary(analysisContext, _coreLibrarySource);
+    }
+    LibraryElement asyncElement = _asyncLibrary.libraryElement;
+    if (asyncElement == null) {
+      missingAsyncLibrary(analysisContext, _asyncLibrarySource);
+    }
+    _buildDirectiveModels();
+    _typeProvider = new TypeProviderImpl(coreElement, asyncElement);
+    _buildEnumMembers();
+    _buildTypeHierarchies();
+    //
+    // Perform resolution and type analysis.
+    //
+    // TODO(brianwilkerson) Decide whether we want to resolve all of the
+    // libraries or whether we want to only resolve the target library. The
+    // advantage to resolving everything is that we have already done part of
+    // the work so we'll avoid duplicated effort. The disadvantage of
+    // resolving everything is that we might do extra work that we don't
+    // really care about. Another possibility is to add a parameter to this
+    // method and punt the decision to the clients.
+    //
+    //if (analyzeAll) {
+    _resolveReferencesAndTypes();
+    //} else {
+    //  resolveReferencesAndTypes(targetLibrary);
+    //}
+    _performConstantEvaluation();
+    return targetLibrary.libraryElement;
+  }
+
+  /**
+   * Build the element model representing the combinators declared by the given directive.
+   *
+   * @param directive the directive that declares the combinators
+   * @return an array containing the import combinators that were built
+   */
+  List<NamespaceCombinator> _buildCombinators(NamespaceDirective directive) {
+    List<NamespaceCombinator> combinators = new List<NamespaceCombinator>();
+    for (Combinator combinator in directive.combinators) {
+      if (combinator is HideCombinator) {
+        HideElementCombinatorImpl hide = new HideElementCombinatorImpl();
+        hide.hiddenNames = _getIdentifiers(combinator.hiddenNames);
+        combinators.add(hide);
+      } else {
+        ShowElementCombinatorImpl show = new ShowElementCombinatorImpl();
+        show.offset = combinator.offset;
+        show.end = combinator.end;
+        show.shownNames =
+            _getIdentifiers((combinator as ShowCombinator).shownNames);
+        combinators.add(show);
+      }
+    }
+    return combinators;
+  }
+
+  /**
+   * Every library now has a corresponding [LibraryElement], so it is now possible to resolve
+   * the import and export directives.
+   *
+   * @throws AnalysisException if the defining compilation unit for any of the libraries could not
+   *           be accessed
+   */
+  void _buildDirectiveModels() {
+    for (ResolvableLibrary library in _librariesInCycle) {
+      HashMap<String, PrefixElementImpl> nameToPrefixMap =
+          new HashMap<String, PrefixElementImpl>();
+      List<ImportElement> imports = new List<ImportElement>();
+      List<ExportElement> exports = new List<ExportElement>();
+      for (Directive directive in library.definingCompilationUnit.directives) {
+        if (directive is ImportDirective) {
+          ImportDirective importDirective = directive;
+          String uriContent = importDirective.uriContent;
+          if (DartUriResolver.isDartExtUri(uriContent)) {
+            library.libraryElement.hasExtUri = true;
+          }
+          Source importedSource = importDirective.source;
+          if (importedSource != null &&
+              analysisContext.exists(importedSource)) {
+            // The imported source will be null if the URI in the import
+            // directive was invalid.
+            ResolvableLibrary importedLibrary = _libraryMap[importedSource];
+            if (importedLibrary != null) {
+              ImportElementImpl importElement =
+                  new ImportElementImpl(directive.offset);
+              StringLiteral uriLiteral = importDirective.uri;
+              if (uriLiteral != null) {
+                importElement.uriOffset = uriLiteral.offset;
+                importElement.uriEnd = uriLiteral.end;
+              }
+              importElement.uri = uriContent;
+              importElement.deferred = importDirective.deferredKeyword != null;
+              importElement.combinators = _buildCombinators(importDirective);
+              LibraryElement importedLibraryElement =
+                  importedLibrary.libraryElement;
+              if (importedLibraryElement != null) {
+                importElement.importedLibrary = importedLibraryElement;
+              }
+              SimpleIdentifier prefixNode = directive.prefix;
+              if (prefixNode != null) {
+                importElement.prefixOffset = prefixNode.offset;
+                String prefixName = prefixNode.name;
+                PrefixElementImpl prefix = nameToPrefixMap[prefixName];
+                if (prefix == null) {
+                  prefix = new PrefixElementImpl.forNode(prefixNode);
+                  nameToPrefixMap[prefixName] = prefix;
+                }
+                importElement.prefix = prefix;
+                prefixNode.staticElement = prefix;
+              }
+              directive.element = importElement;
+              imports.add(importElement);
+              if (analysisContext.computeKindOf(importedSource) !=
+                  SourceKind.LIBRARY) {
+                ErrorCode errorCode = (importElement.isDeferred
+                    ? StaticWarningCode.IMPORT_OF_NON_LIBRARY
+                    : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
+                _errorListener.onError(new AnalysisError(
+                    library.librarySource,
+                    uriLiteral.offset,
+                    uriLiteral.length,
+                    errorCode,
+                    [uriLiteral.toSource()]));
+              }
+            }
+          }
+        } else if (directive is ExportDirective) {
+          ExportDirective exportDirective = directive;
+          Source exportedSource = exportDirective.source;
+          if (exportedSource != null &&
+              analysisContext.exists(exportedSource)) {
+            // The exported source will be null if the URI in the export
+            // directive was invalid.
+            ResolvableLibrary exportedLibrary = _libraryMap[exportedSource];
+            if (exportedLibrary != null) {
+              ExportElementImpl exportElement =
+                  new ExportElementImpl(directive.offset);
+              StringLiteral uriLiteral = exportDirective.uri;
+              if (uriLiteral != null) {
+                exportElement.uriOffset = uriLiteral.offset;
+                exportElement.uriEnd = uriLiteral.end;
+              }
+              exportElement.uri = exportDirective.uriContent;
+              exportElement.combinators = _buildCombinators(exportDirective);
+              LibraryElement exportedLibraryElement =
+                  exportedLibrary.libraryElement;
+              if (exportedLibraryElement != null) {
+                exportElement.exportedLibrary = exportedLibraryElement;
+              }
+              directive.element = exportElement;
+              exports.add(exportElement);
+              if (analysisContext.computeKindOf(exportedSource) !=
+                  SourceKind.LIBRARY) {
+                _errorListener.onError(new AnalysisError(
+                    library.librarySource,
+                    uriLiteral.offset,
+                    uriLiteral.length,
+                    CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY,
+                    [uriLiteral.toSource()]));
+              }
+            }
+          }
+        }
+      }
+      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 = imports;
+      libraryElement.exports = exports;
+      if (libraryElement.entryPoint == null) {
+        Namespace namespace = new NamespaceBuilder()
+            .createExportNamespaceForLibrary(libraryElement);
+        Element element = namespace.get(FunctionElement.MAIN_FUNCTION_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 (ResolvableLibrary library in _librariesInCycle) {
+      LibraryElementBuilder builder =
+          new LibraryElementBuilder(analysisContext, errorListener);
+      builder.buildLibrary2(library);
+    }
+  }
+
+  /**
+   * Build the members in enum declarations. This cannot be done while building the rest of the
+   * element model because it depends on being able to access core types, which cannot happen until
+   * the rest of the element model has been built (when resolving the core library).
+   *
+   * @throws AnalysisException if any of the enum members could not be built
+   */
+  void _buildEnumMembers() {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
+      for (ResolvableLibrary library in _librariesInCycle) {
+        for (Source source in library.compilationUnitSources) {
+          EnumMemberBuilder builder = new EnumMemberBuilder(_typeProvider);
+          library.getAST(source).accept(builder);
+        }
+      }
+    });
+  }
+
+  HashMap<Source, ResolvableLibrary> _buildLibraryMap() {
+    HashMap<Source, ResolvableLibrary> libraryMap =
+        new HashMap<Source, ResolvableLibrary>();
+    int libraryCount = _librariesInCycle.length;
+    for (int i = 0; i < libraryCount; i++) {
+      ResolvableLibrary library = _librariesInCycle[i];
+      library.errorListener = _errorListener;
+      libraryMap[library.librarySource] = library;
+      List<ResolvableLibrary> dependencies = library.importsAndExports;
+      int dependencyCount = dependencies.length;
+      for (int j = 0; j < dependencyCount; j++) {
+        ResolvableLibrary dependency = dependencies[j];
+        //dependency.setErrorListener(errorListener);
+        libraryMap[dependency.librarySource] = dependency;
+      }
+    }
+    return libraryMap;
+  }
+
+  /**
+   * Resolve the type hierarchy across all of the types declared in the libraries in the current
+   * cycle.
+   *
+   * @throws AnalysisException if any of the type hierarchies could not be resolved
+   */
+  void _buildTypeHierarchies() {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
+      for (ResolvableLibrary library in _librariesInCycle) {
+        for (ResolvableCompilationUnit unit
+            in library.resolvableCompilationUnits) {
+          Source source = unit.source;
+          CompilationUnit ast = unit.compilationUnit;
+          TypeResolverVisitor visitor = new TypeResolverVisitor(
+              library.libraryElement,
+              source,
+              _typeProvider,
+              library.libraryScope.errorListener,
+              nameScope: library.libraryScope);
+          ast.accept(visitor);
+        }
+      }
+    });
+  }
+
+  /**
+   * Return an array containing the lexical identifiers associated with the nodes in the given list.
+   *
+   * @param names the AST nodes representing the identifiers
+   * @return the lexical identifiers associated with the nodes in the list
+   */
+  List<String> _getIdentifiers(NodeList<SimpleIdentifier> names) {
+    int count = names.length;
+    List<String> identifiers = new List<String>(count);
+    for (int i = 0; i < count; i++) {
+      identifiers[i] = names[i].name;
+    }
+    return identifiers;
+  }
+
+  /**
+   * Compute a value for all of the constants in the libraries being analyzed.
+   */
+  void _performConstantEvaluation() {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
+      ConstantValueComputer computer = new ConstantValueComputer(
+          analysisContext, _typeProvider, analysisContext.declaredVariables);
+      for (ResolvableLibrary library in _librariesInCycle) {
+        for (ResolvableCompilationUnit unit
+            in library.resolvableCompilationUnits) {
+          CompilationUnit ast = unit.compilationUnit;
+          if (ast != null) {
+            computer.add(ast, unit.source, library.librarySource);
+          }
+        }
+      }
+      computer.computeValues();
+      // As a temporary workaround for issue 21572, run ConstantVerifier now.
+      // TODO(paulberry): remove this workaround once issue 21572 is fixed.
+      for (ResolvableLibrary library in _librariesInCycle) {
+        for (ResolvableCompilationUnit unit
+            in library.resolvableCompilationUnits) {
+          CompilationUnit ast = unit.compilationUnit;
+          ErrorReporter errorReporter =
+              new ErrorReporter(_errorListener, unit.source);
+          ConstantVerifier constantVerifier = new ConstantVerifier(
+              errorReporter,
+              library.libraryElement,
+              _typeProvider,
+              analysisContext.declaredVariables);
+          ast.accept(constantVerifier);
+        }
+      }
+    });
+  }
+
+  /**
+   * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
+   *
+   * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
+   *           libraries could not have their types analyzed
+   */
+  void _resolveReferencesAndTypes() {
+    for (ResolvableLibrary library in _librariesInCycle) {
+      _resolveReferencesAndTypesInLibrary(library);
+    }
+  }
+
+  /**
+   * Resolve the identifiers and perform type analysis in the given library.
+   *
+   * @param library the library to be resolved
+   * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
+   *           the library cannot be analyzed
+   */
+  void _resolveReferencesAndTypesInLibrary(ResolvableLibrary library) {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
+      for (ResolvableCompilationUnit unit
+          in library.resolvableCompilationUnits) {
+        Source source = unit.source;
+        CompilationUnit ast = unit.compilationUnit;
+        ast.accept(new VariableResolverVisitor(library.libraryElement, source,
+            _typeProvider, library.libraryScope.errorListener,
+            nameScope: library.libraryScope));
+        ResolverVisitor visitor = new ResolverVisitor(library.libraryElement,
+            source, _typeProvider, library._libraryScope.errorListener,
+            nameScope: library._libraryScope,
+            inheritanceManager: library.inheritanceManager);
+        ast.accept(visitor);
+      }
+    });
+  }
+
+  /**
+   * Report that the async library could not be resolved in the given
+   * [analysisContext] and throw an exception.  [asyncLibrarySource] is the source
+   * representing the async library.
+   */
+  static void missingAsyncLibrary(
+      AnalysisContext analysisContext, Source asyncLibrarySource) {
+    throw new AnalysisException("Could not resolve dart:async");
+  }
+
+  /**
+   * Report that the core library could not be resolved in the given analysis context and throw an
+   * exception.
+   *
+   * @param analysisContext the analysis context in which the failure occurred
+   * @param coreLibrarySource the source representing the core library
+   * @throws AnalysisException always
+   */
+  static void missingCoreLibrary(
+      AnalysisContext analysisContext, Source coreLibrarySource) {
+    throw new AnalysisException("Could not resolve dart:core");
+  }
+}
+
+/**
+ * Instances of the class `TypeAliasInfo` hold information about a [TypeAlias].
+ */
+class LibraryResolver2_TypeAliasInfo {
+  final ResolvableLibrary _library;
+
+  final Source _source;
+
+  final FunctionTypeAlias _typeAlias;
+
+  /**
+   * Initialize a newly created information holder with the given information.
+   *
+   * @param library the library containing the type alias
+   * @param source the source of the file containing the type alias
+   * @param typeAlias the type alias being remembered
+   */
+  LibraryResolver2_TypeAliasInfo(this._library, this._source, this._typeAlias);
+}
+
+/**
+ * Instances of the class `TypeAliasInfo` hold information about a [TypeAlias].
+ */
+class LibraryResolver_TypeAliasInfo {
+  final Library _library;
+
+  final Source _source;
+
+  final FunctionTypeAlias _typeAlias;
+
+  /**
+   * Initialize a newly created information holder with the given information.
+   *
+   * @param library the library containing the type alias
+   * @param source the source of the file containing the type alias
+   * @param typeAlias the type alias being remembered
+   */
+  LibraryResolver_TypeAliasInfo(this._library, this._source, this._typeAlias);
+}
+
+/**
+ * Instances of the class `LibraryScope` implement a scope containing all of the names defined
+ * in a given library.
+ */
+class LibraryScope extends EnclosedScope {
+  /**
+   * Initialize a newly created scope representing the names defined in the given library.
+   *
+   * @param definingLibrary the element representing the library represented by this scope
+   * @param errorListener the listener that is to be informed when an error is encountered
+   */
+  LibraryScope(
+      LibraryElement definingLibrary, AnalysisErrorListener errorListener)
+      : super(new LibraryImportScope(definingLibrary, errorListener)) {
+    _defineTopLevelNames(definingLibrary);
+  }
+
+  @override
+  AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
+    if (existing is PrefixElement) {
+      // TODO(scheglov) consider providing actual 'nameOffset' from the
+      // synthetic accessor
+      int offset = duplicate.nameOffset;
+      if (duplicate is PropertyAccessorElement) {
+        PropertyAccessorElement accessor = duplicate;
+        if (accessor.isSynthetic) {
+          offset = accessor.variable.nameOffset;
+        }
+      }
+      return new AnalysisError(
+          duplicate.source,
+          offset,
+          duplicate.displayName.length,
+          CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER,
+          [existing.displayName]);
+    }
+    return super.getErrorForDuplicate(existing, duplicate);
+  }
+
+  /**
+   * Add to this scope all of the public top-level names that are defined in the given compilation
+   * unit.
+   *
+   * @param compilationUnit the compilation unit defining the top-level names to be added to this
+   *          scope
+   */
+  void _defineLocalNames(CompilationUnitElement compilationUnit) {
+    for (PropertyAccessorElement element in compilationUnit.accessors) {
+      define(element);
+    }
+    for (ClassElement element in compilationUnit.enums) {
+      define(element);
+    }
+    for (FunctionElement element in compilationUnit.functions) {
+      define(element);
+    }
+    for (FunctionTypeAliasElement element
+        in compilationUnit.functionTypeAliases) {
+      define(element);
+    }
+    for (ClassElement element in compilationUnit.types) {
+      define(element);
+    }
+  }
+
+  /**
+   * Add to this scope all of the names that are explicitly defined in the given library.
+   *
+   * @param definingLibrary the element representing the library that defines the names in this
+   *          scope
+   */
+  void _defineTopLevelNames(LibraryElement definingLibrary) {
+    for (PrefixElement prefix in definingLibrary.prefixes) {
+      define(prefix);
+    }
+    _defineLocalNames(definingLibrary.definingCompilationUnit);
+    for (CompilationUnitElement compilationUnit in definingLibrary.parts) {
+      _defineLocalNames(compilationUnit);
+    }
+  }
+}
+
+/**
+ * This class is used to replace uses of `HashMap<String, ExecutableElement>`
+ * which are not as performant as this class.
+ */
+class MemberMap {
+  /**
+   * The current size of this map.
+   */
+  int _size = 0;
+
+  /**
+   * The array of keys.
+   */
+  List<String> _keys;
+
+  /**
+   * The array of ExecutableElement values.
+   */
+  List<ExecutableElement> _values;
+
+  /**
+   * Initialize a newly created member map to have the given [initialCapacity].
+   * The map will grow if needed.
+   */
+  MemberMap([int initialCapacity = 10]) {
+    _initArrays(initialCapacity);
+  }
+
+  /**
+   * This constructor takes an initial capacity of the map.
+   *
+   * @param initialCapacity the initial capacity
+   */
+  @deprecated // Use new MemberMap(initialCapacity)
+  MemberMap.con1(int initialCapacity) {
+    _initArrays(initialCapacity);
+  }
+
+  /**
+   * Copy constructor.
+   */
+  @deprecated // Use new MemberMap.from(memberMap)
+  MemberMap.con2(MemberMap memberMap) {
+    _initArrays(memberMap._size + 5);
+    for (int i = 0; i < memberMap._size; i++) {
+      _keys[i] = memberMap._keys[i];
+      _values[i] = memberMap._values[i];
+    }
+    _size = memberMap._size;
+  }
+
+  /**
+   * Initialize a newly created member map to contain the same members as the
+   * given [memberMap].
+   */
+  MemberMap.from(MemberMap memberMap) {
+    _initArrays(memberMap._size + 5);
+    for (int i = 0; i < memberMap._size; i++) {
+      _keys[i] = memberMap._keys[i];
+      _values[i] = memberMap._values[i];
+    }
+    _size = memberMap._size;
+  }
+
+  /**
+   * The size of the map.
+   *
+   * @return the size of the map.
+   */
+  int get size => _size;
+
+  /**
+   * Given some key, return the ExecutableElement value from the map, if the key does not exist in
+   * the map, `null` is returned.
+   *
+   * @param key some key to look up in the map
+   * @return the associated ExecutableElement value from the map, if the key does not exist in the
+   *         map, `null` is returned
+   */
+  ExecutableElement get(String key) {
+    for (int i = 0; i < _size; i++) {
+      if (_keys[i] != null && _keys[i] == key) {
+        return _values[i];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get and return the key at the specified location. If the key/value pair has been removed from
+   * the set, then `null` is returned.
+   *
+   * @param i some non-zero value less than size
+   * @return the key at the passed index
+   * @throw ArrayIndexOutOfBoundsException this exception is thrown if the passed index is less than
+   *        zero or greater than or equal to the capacity of the arrays
+   */
+  String getKey(int i) => _keys[i];
+
+  /**
+   * Get and return the ExecutableElement at the specified location. If the key/value pair has been
+   * removed from the set, then then `null` is returned.
+   *
+   * @param i some non-zero value less than size
+   * @return the key at the passed index
+   * @throw ArrayIndexOutOfBoundsException this exception is thrown if the passed index is less than
+   *        zero or greater than or equal to the capacity of the arrays
+   */
+  ExecutableElement getValue(int i) => _values[i];
+
+  /**
+   * Given some key/value pair, store the pair in the map. If the key exists already, then the new
+   * value overrides the old value.
+   *
+   * @param key the key to store in the map
+   * @param value the ExecutableElement value to store in the map
+   */
+  void put(String key, ExecutableElement value) {
+    // If we already have a value with this key, override the value
+    for (int i = 0; i < _size; i++) {
+      if (_keys[i] != null && _keys[i] == key) {
+        _values[i] = value;
+        return;
+      }
+    }
+    // If needed, double the size of our arrays and copy values over in both
+    // arrays
+    if (_size == _keys.length) {
+      int newArrayLength = _size * 2;
+      List<String> keys_new_array = new List<String>(newArrayLength);
+      List<ExecutableElement> values_new_array =
+          new List<ExecutableElement>(newArrayLength);
+      for (int i = 0; i < _size; i++) {
+        keys_new_array[i] = _keys[i];
+      }
+      for (int i = 0; i < _size; i++) {
+        values_new_array[i] = _values[i];
+      }
+      _keys = keys_new_array;
+      _values = values_new_array;
+    }
+    // Put new value at end of array
+    _keys[_size] = key;
+    _values[_size] = value;
+    _size++;
+  }
+
+  /**
+   * Given some [String] key, this method replaces the associated key and value pair with
+   * `null`. The size is not decremented with this call, instead it is expected that the users
+   * check for `null`.
+   *
+   * @param key the key of the key/value pair to remove from the map
+   */
+  void remove(String key) {
+    for (int i = 0; i < _size; i++) {
+      if (_keys[i] == key) {
+        _keys[i] = null;
+        _values[i] = null;
+        return;
+      }
+    }
+  }
+
+  /**
+   * Sets the ExecutableElement at the specified location.
+   *
+   * @param i some non-zero value less than size
+   * @param value the ExecutableElement value to store in the map
+   */
+  void setValue(int i, ExecutableElement value) {
+    _values[i] = value;
+  }
+
+  /**
+   * Initializes [keys] and [values].
+   */
+  void _initArrays(int initialCapacity) {
+    _keys = new List<String>(initialCapacity);
+    _values = new List<ExecutableElement>(initialCapacity);
+  }
+}
+
+/**
+ * Instances of the class `Namespace` implement a mapping of identifiers to the elements
+ * represented by those identifiers. Namespaces are the building blocks for scopes.
+ */
+class Namespace {
+  /**
+   * An empty namespace.
+   */
+  static Namespace EMPTY = new Namespace(new HashMap<String, Element>());
+
+  /**
+   * A table mapping names that are defined in this namespace to the element representing the thing
+   * declared with that name.
+   */
+  final HashMap<String, Element> _definedNames;
+
+  /**
+   * Initialize a newly created namespace to have the given defined names.
+   *
+   * @param definedNames the mapping from names that are defined in this namespace to the
+   *          corresponding elements
+   */
+  Namespace(this._definedNames);
+
+  /**
+   * Return a table containing the same mappings as those defined by this namespace.
+   *
+   * @return a table containing the same mappings as those defined by this namespace
+   */
+  Map<String, Element> get definedNames =>
+      new HashMap<String, Element>.from(_definedNames);
+
+  /**
+   * Return the element in this namespace that is available to the containing scope using the given
+   * name.
+   *
+   * @param name the name used to reference the
+   * @return the element represented by the given identifier
+   */
+  Element get(String name) => _definedNames[name];
+}
+
+/**
+ * Instances of the class `NamespaceBuilder` are used to build a `Namespace`. Namespace
+ * builders are thread-safe and re-usable.
+ */
+class NamespaceBuilder {
+  /**
+   * Create a namespace representing the export namespace of the given [ExportElement].
+   *
+   * @param element the export element whose export namespace is to be created
+   * @return the export namespace that was created
+   */
+  Namespace createExportNamespaceForDirective(ExportElement element) {
+    LibraryElement exportedLibrary = element.exportedLibrary;
+    if (exportedLibrary == null) {
+      //
+      // The exported library will be null if the URI does not reference a valid
+      // library.
+      //
+      return Namespace.EMPTY;
+    }
+    HashMap<String, Element> definedNames =
+        _createExportMapping(exportedLibrary, new HashSet<LibraryElement>());
+    definedNames = _applyCombinators(definedNames, element.combinators);
+    return new Namespace(definedNames);
+  }
+
+  /**
+   * Create a namespace representing the export namespace of the given library.
+   *
+   * @param library the library whose export namespace is to be created
+   * @return the export namespace that was created
+   */
+  Namespace createExportNamespaceForLibrary(LibraryElement library) =>
+      new Namespace(
+          _createExportMapping(library, new HashSet<LibraryElement>()));
+
+  /**
+   * Create a namespace representing the import namespace of the given library.
+   *
+   * @param library the library whose import namespace is to be created
+   * @return the import namespace that was created
+   */
+  Namespace createImportNamespaceForDirective(ImportElement element) {
+    LibraryElement importedLibrary = element.importedLibrary;
+    if (importedLibrary == null) {
+      //
+      // The imported library will be null if the URI does not reference a valid
+      // library.
+      //
+      return Namespace.EMPTY;
+    }
+    HashMap<String, Element> definedNames =
+        _createExportMapping(importedLibrary, new HashSet<LibraryElement>());
+    definedNames = _applyCombinators(definedNames, element.combinators);
+    definedNames = _applyPrefix(definedNames, element.prefix);
+    return new Namespace(definedNames);
+  }
+
+  /**
+   * Create a namespace representing the public namespace of the given library.
+   *
+   * @param library the library whose public namespace is to be created
+   * @return the public namespace that was created
+   */
+  Namespace createPublicNamespaceForLibrary(LibraryElement library) {
+    HashMap<String, Element> definedNames = new HashMap<String, Element>();
+    _addPublicNames(definedNames, library.definingCompilationUnit);
+    for (CompilationUnitElement compilationUnit in library.parts) {
+      _addPublicNames(definedNames, compilationUnit);
+    }
+    return new Namespace(definedNames);
+  }
+
+  /**
+   * Add all of the names in the given namespace to the given mapping table.
+   *
+   * @param definedNames the mapping table to which the names in the given namespace are to be added
+   * @param namespace the namespace containing the names to be added to this namespace
+   */
+  void _addAllFromNamespace(
+      Map<String, Element> definedNames, Namespace namespace) {
+    if (namespace != null) {
+      definedNames.addAll(namespace.definedNames);
+    }
+  }
+
+  /**
+   * Add the given element to the given mapping table if it has a publicly visible name.
+   *
+   * @param definedNames the mapping table to which the public name is to be added
+   * @param element the element to be added
+   */
+  void _addIfPublic(Map<String, Element> definedNames, Element element) {
+    String name = element.name;
+    if (name != null && !Scope.isPrivateName(name)) {
+      definedNames[name] = element;
+    }
+  }
+
+  /**
+   * Add to the given mapping table all of the public top-level names that are defined in the given
+   * compilation unit.
+   *
+   * @param definedNames the mapping table to which the public names are to be added
+   * @param compilationUnit the compilation unit defining the top-level names to be added to this
+   *          namespace
+   */
+  void _addPublicNames(Map<String, Element> definedNames,
+      CompilationUnitElement compilationUnit) {
+    for (PropertyAccessorElement element in compilationUnit.accessors) {
+      _addIfPublic(definedNames, element);
+    }
+    for (ClassElement element in compilationUnit.enums) {
+      _addIfPublic(definedNames, element);
+    }
+    for (FunctionElement element in compilationUnit.functions) {
+      _addIfPublic(definedNames, element);
+    }
+    for (FunctionTypeAliasElement element
+        in compilationUnit.functionTypeAliases) {
+      _addIfPublic(definedNames, element);
+    }
+    for (ClassElement element in compilationUnit.types) {
+      _addIfPublic(definedNames, element);
+    }
+  }
+
+  /**
+   * Apply the given combinators to all of the names in the given mapping table.
+   *
+   * @param definedNames the mapping table to which the namespace operations are to be applied
+   * @param combinators the combinators to be applied
+   */
+  HashMap<String, Element> _applyCombinators(
+      HashMap<String, Element> definedNames,
+      List<NamespaceCombinator> combinators) {
+    for (NamespaceCombinator combinator in combinators) {
+      if (combinator is HideElementCombinator) {
+        _hide(definedNames, combinator.hiddenNames);
+      } else if (combinator is ShowElementCombinator) {
+        definedNames = _show(definedNames, combinator.shownNames);
+      } else {
+        // Internal error.
+        AnalysisEngine.instance.logger
+            .logError("Unknown type of combinator: ${combinator.runtimeType}");
+      }
+    }
+    return definedNames;
+  }
+
+  /**
+   * Apply the given prefix to all of the names in the table of defined names.
+   *
+   * @param definedNames the names that were defined before this operation
+   * @param prefixElement the element defining the prefix to be added to the names
+   */
+  HashMap<String, Element> _applyPrefix(
+      HashMap<String, Element> definedNames, PrefixElement prefixElement) {
+    if (prefixElement != null) {
+      String prefix = prefixElement.name;
+      HashMap<String, Element> newNames = new HashMap<String, Element>();
+      definedNames.forEach((String name, Element element) {
+        newNames["$prefix.$name"] = element;
+      });
+      return newNames;
+    } else {
+      return definedNames;
+    }
+  }
+
+  /**
+   * Create a mapping table representing the export namespace of the given library.
+   *
+   * @param library the library whose public namespace is to be created
+   * @param visitedElements a set of libraries that do not need to be visited when processing the
+   *          export directives of the given library because all of the names defined by them will
+   *          be added by another library
+   * @return the mapping table that was created
+   */
+  HashMap<String, Element> _createExportMapping(
+      LibraryElement library, HashSet<LibraryElement> visitedElements) {
+    // Check if the export namespace has been already computed.
+    {
+      Namespace exportNamespace = library.exportNamespace;
+      if (exportNamespace != null) {
+        return exportNamespace.definedNames;
+      }
+    }
+    // TODO(scheglov) Remove this after switching to the new task model.
+    visitedElements.add(library);
+    try {
+      HashMap<String, Element> definedNames = new HashMap<String, Element>();
+      for (ExportElement element in library.exports) {
+        LibraryElement exportedLibrary = element.exportedLibrary;
+        if (exportedLibrary != null &&
+            !visitedElements.contains(exportedLibrary)) {
+          //
+          // The exported library will be null if the URI does not reference a
+          // valid library.
+          //
+          HashMap<String, Element> exportedNames =
+              _createExportMapping(exportedLibrary, visitedElements);
+          exportedNames = _applyCombinators(exportedNames, element.combinators);
+          definedNames.addAll(exportedNames);
+        }
+      }
+      _addAllFromNamespace(
+          definedNames,
+          (library.context as InternalAnalysisContext)
+              .getPublicNamespace(library));
+      return definedNames;
+    } finally {
+      visitedElements.remove(library);
+    }
+  }
+
+  /**
+   * Hide all of the given names by removing them from the given collection of defined names.
+   *
+   * @param definedNames the names that were defined before this operation
+   * @param hiddenNames the names to be hidden
+   */
+  void _hide(HashMap<String, Element> definedNames, List<String> hiddenNames) {
+    for (String name in hiddenNames) {
+      definedNames.remove(name);
+      definedNames.remove("$name=");
+    }
+  }
+
+  /**
+   * Show only the given names by removing all other names from the given collection of defined
+   * names.
+   *
+   * @param definedNames the names that were defined before this operation
+   * @param shownNames the names to be shown
+   */
+  HashMap<String, Element> _show(
+      HashMap<String, Element> definedNames, List<String> shownNames) {
+    HashMap<String, Element> newNames = new HashMap<String, Element>();
+    for (String name in shownNames) {
+      Element element = definedNames[name];
+      if (element != null) {
+        newNames[name] = element;
+      }
+      String setterName = "$name=";
+      element = definedNames[setterName];
+      if (element != null) {
+        newNames[setterName] = element;
+      }
+    }
+    return newNames;
+  }
+}
+
+/**
+ * Instances of the class `OverrideVerifier` visit all of the declarations in a compilation
+ * unit to verify that if they have an override annotation it is being used correctly.
+ */
+class OverrideVerifier extends RecursiveAstVisitor<Object> {
+  /**
+   * The error reporter used to report errors.
+   */
+  final ErrorReporter _errorReporter;
+
+  /**
+   * The inheritance manager used to find overridden methods.
+   */
+  final InheritanceManager _manager;
+
+  /**
+   * Initialize a newly created verifier to look for inappropriate uses of the override annotation.
+   *
+   * @param errorReporter the error reporter used to report errors
+   * @param manager the inheritance manager used to find overridden methods
+   */
+  OverrideVerifier(this._errorReporter, this._manager);
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement element = node.element;
+    if (_isOverride(element)) {
+      if (_getOverriddenMember(element) == null) {
+        if (element is MethodElement) {
+          _errorReporter.reportErrorForNode(
+              HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD, node.name);
+        } else if (element is PropertyAccessorElement) {
+          if (element.isGetter) {
+            _errorReporter.reportErrorForNode(
+                HintCode.OVERRIDE_ON_NON_OVERRIDING_GETTER, node.name);
+          } else {
+            _errorReporter.reportErrorForNode(
+                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((element) => element is 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
+   */
+  final AnalysisContext _context;
+
+  /**
+   * The error reporter by which errors will be reported.
+   */
+  final ErrorReporter _errorReporter;
+
+  PubVerifier(this._context, this._errorReporter);
+
+  @override
+  Object visitImportDirective(ImportDirective directive) {
+    return null;
+  }
+
+//  /**
+//   * This verifies that the passed file import directive is not contained in a source inside a
+//   * package "lib" directory hierarchy referencing a source outside that package "lib" directory
+//   * hierarchy.
+//   *
+//   * @param uriLiteral the import URL (not `null`)
+//   * @param path the file path being verified (not `null`)
+//   * @return `true` if and only if an error code is generated on the passed node
+//   * See [PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE].
+//   */
+//  bool
+//      _checkForFileImportInsideLibReferencesFileOutside(StringLiteral uriLiteral,
+//      String path) {
+//    Source source = _getSource(uriLiteral);
+//    String fullName = _getSourceFullName(source);
+//    if (fullName != null) {
+//      int pathIndex = 0;
+//      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 (_context.exists(pubspecSource)) {
+//            // Files inside the lib directory hierarchy should not reference
+//            // files outside
+//            _errorReporter.reportErrorForNode(
+//                HintCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE,
+//                uriLiteral);
+//          }
+//          return true;
+//        }
+//        pathIndex += 3;
+//      }
+//    }
+//    return false;
+//  }
+
+//  /**
+//   * This verifies that the passed file import directive is not contained in a source outside a
+//   * package "lib" directory hierarchy referencing a source inside that package "lib" directory
+//   * hierarchy.
+//   *
+//   * @param uriLiteral the import URL (not `null`)
+//   * @param path the file path being verified (not `null`)
+//   * @return `true` if and only if an error code is generated on the passed node
+//   * See [PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE].
+//   */
+//  bool
+//      _checkForFileImportOutsideLibReferencesFileInside(StringLiteral uriLiteral,
+//      String path) {
+//    if (StringUtilities.startsWith4(path, 0, 0x6C, 0x69, 0x62, 0x2F)) {
+//      if (_checkForFileImportOutsideLibReferencesFileInsideAtIndex(
+//          uriLiteral,
+//          path,
+//          0)) {
+//        return true;
+//      }
+//    }
+//    int pathIndex =
+//        StringUtilities.indexOf5(path, 0, 0x2F, 0x6C, 0x69, 0x62, 0x2F);
+//    while (pathIndex != -1) {
+//      if (_checkForFileImportOutsideLibReferencesFileInsideAtIndex(
+//          uriLiteral,
+//          path,
+//          pathIndex + 1)) {
+//        return true;
+//      }
+//      pathIndex =
+//          StringUtilities.indexOf5(path, pathIndex + 4, 0x2F, 0x6C, 0x69, 0x62, 0x2F);
+//    }
+//    return false;
+//  }
+
+//  bool
+//      _checkForFileImportOutsideLibReferencesFileInsideAtIndex(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 (!_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.reportErrorForNode(
+//            HintCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE,
+//            uriLiteral);
+//        return true;
+//      }
+//    }
+//    return false;
+//  }
+
+//  /**
+//   * This verifies that the passed package import directive does not contain ".."
+//   *
+//   * @param uriLiteral the import URL (not `null`)
+//   * @param path the path to be validated (not `null`)
+//   * @return `true` if and only if an error code is generated on the passed node
+//   * See [PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT].
+//   */
+//  bool _checkForPackageImportContainsDotDot(StringLiteral uriLiteral,
+//      String path) {
+//    if (StringUtilities.startsWith3(path, 0, 0x2E, 0x2E, 0x2F) ||
+//        StringUtilities.indexOf4(path, 0, 0x2F, 0x2E, 0x2E, 0x2F) >= 0) {
+//      // Package import should not to contain ".."
+//      _errorReporter.reportErrorForNode(
+//          HintCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT,
+//          uriLiteral);
+//      return true;
+//    }
+//    return false;
+//  }
+
+//  /**
+//   * Answer the source associated with the compilation unit containing the given AST node.
+//   *
+//   * @param node the node (not `null`)
+//   * @return the source or `null` if it could not be determined
+//   */
+//  Source _getSource(AstNode node) {
+//    Source source = null;
+//    CompilationUnit unit = node.getAncestor((node) => node is CompilationUnit);
+//    if (unit != null) {
+//      CompilationUnitElement element = unit.element;
+//      if (element != null) {
+//        source = element.source;
+//      }
+//    }
+//    return source;
+//  }
+
+//  /**
+//   * Answer the full name of the given source. The returned value will have all
+//   * [File.separatorChar] replace by '/'.
+//   *
+//   * @param source the source
+//   * @return the full name or `null` if it could not be determined
+//   */
+//  String _getSourceFullName(Source source) {
+//    if (source != null) {
+//      String fullName = source.fullName;
+//      if (fullName != null) {
+//        return fullName.replaceAll(r'\', '/');
+//      }
+//    }
+//    return null;
+//  }
+}
+
+/**
+ * Kind of the redirecting constructor.
+ */
+class RedirectingConstructorKind extends Enum<RedirectingConstructorKind> {
+  static const RedirectingConstructorKind CONST =
+      const RedirectingConstructorKind('CONST', 0);
+
+  static const RedirectingConstructorKind NORMAL =
+      const RedirectingConstructorKind('NORMAL', 1);
+
+  static const List<RedirectingConstructorKind> values = const [CONST, NORMAL];
+
+  const RedirectingConstructorKind(String name, int ordinal)
+      : super(name, ordinal);
+}
+
+/**
+ * A `ResolvableLibrary` represents a single library during the resolution of
+ * some (possibly different) library. They are not intended to be used except
+ * during the resolution process.
+ */
+class ResolvableLibrary {
+  /**
+   * An empty array that can be used to initialize lists of libraries.
+   */
+  static List<ResolvableLibrary> _EMPTY_ARRAY = new List<ResolvableLibrary>(0);
+
+  /**
+   * The next artificial hash code.
+   */
+  static int _NEXT_HASH_CODE = 0;
+
+  /**
+   * The artifitial hash code for this object.
+   */
+  final int _hashCode = _nextHashCode();
+
+  /**
+   * The source specifying the defining compilation unit of this library.
+   */
+  final Source librarySource;
+
+  /**
+   * A list containing all of the libraries that are imported into this library.
+   */
+  List<ResolvableLibrary> _importedLibraries = _EMPTY_ARRAY;
+
+  /**
+   * A flag indicating whether this library explicitly imports core.
+   */
+  bool explicitlyImportsCore = false;
+
+  /**
+   * An array containing all of the libraries that are exported from this library.
+   */
+  List<ResolvableLibrary> _exportedLibraries = _EMPTY_ARRAY;
+
+  /**
+   * An array containing the compilation units that comprise this library. The
+   * defining compilation unit is always first.
+   */
+  List<ResolvableCompilationUnit> _compilationUnits;
+
+  /**
+   * The library element representing this library.
+   */
+  LibraryElementImpl _libraryElement;
+
+  /**
+   * The listener to which analysis errors will be reported.
+   */
+  AnalysisErrorListener _errorListener;
+
+  /**
+   * The inheritance manager which is used for member lookups in this library.
+   */
+  InheritanceManager _inheritanceManager;
+
+  /**
+   * The library scope used when resolving elements within this library's compilation units.
+   */
+  LibraryScope _libraryScope;
+
+  /**
+   * Initialize a newly created data holder that can maintain the data associated with a library.
+   *
+   * @param librarySource the source specifying the defining compilation unit of this library
+   * @param errorListener the listener to which analysis errors will be reported
+   */
+  ResolvableLibrary(this.librarySource);
+
+  /**
+   * Return an array of the [CompilationUnit]s that make up the library. The first unit is
+   * always the defining unit.
+   *
+   * @return an array of the [CompilationUnit]s that make up the library. The first unit is
+   *         always the defining unit
+   */
+  List<CompilationUnit> get compilationUnits {
+    int count = _compilationUnits.length;
+    List<CompilationUnit> units = new List<CompilationUnit>(count);
+    for (int i = 0; i < count; i++) {
+      units[i] = _compilationUnits[i].compilationUnit;
+    }
+    return units;
+  }
+
+  /**
+   * Return an array containing the sources for the compilation units in this library, including the
+   * defining compilation unit.
+   *
+   * @return the sources for the compilation units in this library
+   */
+  List<Source> get compilationUnitSources {
+    int count = _compilationUnits.length;
+    List<Source> sources = new List<Source>(count);
+    for (int i = 0; i < count; i++) {
+      sources[i] = _compilationUnits[i].source;
+    }
+    return sources;
+  }
+
+  /**
+   * Return the AST structure associated with the defining compilation unit for this library.
+   *
+   * @return the AST structure associated with the defining compilation unit for this library
+   * @throws AnalysisException if an AST structure could not be created for the defining compilation
+   *           unit
+   */
+  CompilationUnit get definingCompilationUnit =>
+      _compilationUnits[0].compilationUnit;
+
+  /**
+   * Set the listener to which analysis errors will be reported to be the given listener.
+   *
+   * @param errorListener the listener to which analysis errors will be reported
+   */
+  void set errorListener(AnalysisErrorListener errorListener) {
+    this._errorListener = errorListener;
+  }
+
+  /**
+   * Set the libraries that are exported by this library to be those in the given array.
+   *
+   * @param exportedLibraries the libraries that are exported by this library
+   */
+  void set exportedLibraries(List<ResolvableLibrary> exportedLibraries) {
+    this._exportedLibraries = exportedLibraries;
+  }
+
+  /**
+   * Return an array containing the libraries that are exported from this library.
+   *
+   * @return an array containing the libraries that are exported from this library
+   */
+  List<ResolvableLibrary> get exports => _exportedLibraries;
+
+  @override
+  int get hashCode => _hashCode;
+
+  /**
+   * Set the libraries that are imported into this library to be those in the given array.
+   *
+   * @param importedLibraries the libraries that are imported into this library
+   */
+  void set importedLibraries(List<ResolvableLibrary> importedLibraries) {
+    this._importedLibraries = importedLibraries;
+  }
+
+  /**
+   * Return an array containing the libraries that are imported into this library.
+   *
+   * @return an array containing the libraries that are imported into this library
+   */
+  List<ResolvableLibrary> get imports => _importedLibraries;
+
+  /**
+   * Return an array containing the libraries that are either imported or exported from this
+   * library.
+   *
+   * @return the libraries that are either imported or exported from this library
+   */
+  List<ResolvableLibrary> get importsAndExports {
+    HashSet<ResolvableLibrary> libraries = new HashSet<ResolvableLibrary>();
+    for (ResolvableLibrary library in _importedLibraries) {
+      libraries.add(library);
+    }
+    for (ResolvableLibrary library in _exportedLibraries) {
+      libraries.add(library);
+    }
+    return new List.from(libraries);
+  }
+
+  /**
+   * Return the inheritance manager for this library.
+   *
+   * @return the inheritance manager for this library
+   */
+  InheritanceManager get inheritanceManager {
+    if (_inheritanceManager == null) {
+      return _inheritanceManager = new InheritanceManager(_libraryElement);
+    }
+    return _inheritanceManager;
+  }
+
+  /**
+   * Return the library element representing this library, creating it if necessary.
+   *
+   * @return the library element representing this library
+   */
+  LibraryElementImpl get libraryElement => _libraryElement;
+
+  /**
+   * Set the library element representing this library to the given library element.
+   *
+   * @param libraryElement the library element representing this library
+   */
+  void set libraryElement(LibraryElementImpl libraryElement) {
+    this._libraryElement = libraryElement;
+    if (_inheritanceManager != null) {
+      _inheritanceManager.libraryElement = libraryElement;
+    }
+  }
+
+  /**
+   * Return the library scope used when resolving elements within this library's compilation units.
+   *
+   * @return the library scope used when resolving elements within this library's compilation units
+   */
+  LibraryScope get libraryScope {
+    if (_libraryScope == null) {
+      _libraryScope = new LibraryScope(_libraryElement, _errorListener);
+    }
+    return _libraryScope;
+  }
+
+  /**
+   * Return an array containing the compilation units that comprise this library. The defining
+   * compilation unit is always first.
+   *
+   * @return the compilation units that comprise this library
+   */
+  List<ResolvableCompilationUnit> get resolvableCompilationUnits =>
+      _compilationUnits;
+
+  /**
+   * Set the compilation unit in this library to the given compilation units. The defining
+   * compilation unit must be the first element of the array.
+   *
+   * @param units the compilation units in this library
+   */
+  void set resolvableCompilationUnits(List<ResolvableCompilationUnit> units) {
+    _compilationUnits = units;
+  }
+
+  /**
+   * Return the AST structure associated with the given source, or `null` if the source does
+   * not represent a compilation unit that is included in this library.
+   *
+   * @param source the source representing the compilation unit whose AST is to be returned
+   * @return the AST structure associated with the given source
+   * @throws AnalysisException if an AST structure could not be created for the compilation unit
+   */
+  CompilationUnit getAST(Source source) {
+    int count = _compilationUnits.length;
+    for (int i = 0; i < count; i++) {
+      if (_compilationUnits[i].source == source) {
+        return _compilationUnits[i].compilationUnit;
+      }
+    }
+    return null;
+  }
+
+  @override
+  String toString() => librarySource.shortName;
+
+  static int _nextHashCode() {
+    int next = (_NEXT_HASH_CODE + 1) & 0xFFFFFF;
+    _NEXT_HASH_CODE = next;
+    return next;
+  }
+}
+
+/**
+ * The enumeration `ResolverErrorCode` defines the error codes used for errors
+ * detected by the resolver. The convention for this class is for the name of
+ * the error code to indicate the problem that caused the error to be generated
+ * and for the error message to explain what is wrong and, when appropriate, how
+ * the problem can be corrected.
+ */
+class ResolverErrorCode extends ErrorCode {
+  static const ResolverErrorCode BREAK_LABEL_ON_SWITCH_MEMBER =
+      const ResolverErrorCode('BREAK_LABEL_ON_SWITCH_MEMBER',
+          "Break label resolves to case or default statement");
+
+  static const ResolverErrorCode CONTINUE_LABEL_ON_SWITCH =
+      const ResolverErrorCode('CONTINUE_LABEL_ON_SWITCH',
+          "A continue label resolves to switch, must be loop or switch member");
+
+  static const ResolverErrorCode MISSING_LIBRARY_DIRECTIVE_WITH_PART =
+      const ResolverErrorCode('MISSING_LIBRARY_DIRECTIVE_WITH_PART',
+          "Libraries that have parts must have a library directive");
+
+  /**
+   * Initialize a newly created error code to have the given [name]. The message
+   * associated with the error will be created from the given [message]
+   * template. The correction associated with the error will be created from the
+   * given [correction] template.
+   */
+  const ResolverErrorCode(String name, String message, [String correction])
+      : super(name, message, correction);
+
+  @override
+  ErrorSeverity get errorSeverity => type.severity;
+
+  @override
+  ErrorType get type => ErrorType.COMPILE_TIME_ERROR;
+}
+
+/**
+ * Instances of the class `ResolverVisitor` are used to resolve the nodes within a single
+ * compilation unit.
+ */
+class ResolverVisitor extends ScopedVisitor {
+  /**
+   * The manager for the inheritance mappings.
+   */
+  InheritanceManager _inheritanceManager;
+
+  /**
+   * The object used to resolve the element associated with the current node.
+   */
+  ElementResolver elementResolver;
+
+  /**
+   * The object used to compute the type associated with the current node.
+   */
+  StaticTypeAnalyzer typeAnalyzer;
+
+  /**
+   * The class element representing the class containing the current node,
+   * or `null` if the current node is not contained in a class.
+   */
+  ClassElement enclosingClass = null;
+
+  /**
+   * The class declaration representing the class containing the current node, or `null` if
+   * the current node is not contained in a class.
+   */
+  ClassDeclaration _enclosingClassDeclaration = null;
+
+  /**
+   * The function type alias representing the function type containing the current node, or
+   * `null` if the current node is not contained in a function type alias.
+   */
+  FunctionTypeAlias _enclosingFunctionTypeAlias = null;
+
+  /**
+   * The element representing the function containing the current node, or `null` if the
+   * current node is not contained in a function.
+   */
+  ExecutableElement _enclosingFunction = null;
+
+  /**
+   * The [Comment] before a [FunctionDeclaration] or a [MethodDeclaration] that
+   * cannot be resolved where we visited it, because it should be resolved in the scope of the body.
+   */
+  Comment _commentBeforeFunction = null;
+
+  /**
+   * The object keeping track of which elements have had their types overridden.
+   */
+  TypeOverrideManager _overrideManager = new TypeOverrideManager();
+
+  /**
+   * The object keeping track of which elements have had their types promoted.
+   */
+  TypePromotionManager _promoteManager = new TypePromotionManager();
+
+  /**
+   * A comment before a function should be resolved in the context of the
+   * function. But when we incrementally resolve a comment, we don't want to
+   * resolve the whole function.
+   *
+   * So, this flag is set to `true`, when just context of the function should
+   * be built and the comment resolved.
+   */
+  bool resolveOnlyCommentInFunctionBody = false;
+
+  /**
+   * Initialize a newly created visitor to resolve the nodes in an AST node.
+   *
+   * [definingLibrary] is the element for the library containing the node being
+   * visited.
+   * [source] is the source representing the compilation unit containing the
+   * node being visited.
+   * [typeProvider] the object used to access the types from the core library.
+   * [errorListener] the error listener that will be informed of any errors
+   * that are found during resolution.
+   * [nameScope] is the scope used to resolve identifiers in the node that will
+   * first be visited.  If `null` or unspecified, a new [LibraryScope] will be
+   * created based on [definingLibrary] and [typeProvider].
+   * [inheritanceManager] is used to perform inheritance lookups.  If `null` or
+   * unspecified, a new [InheritanceManager] will be created based on
+   * [definingLibrary].
+   * [typeAnalyzerFactory] is used to create the type analyzer.  If `null` or
+   * unspecified, a type analyzer of type [StaticTypeAnalyzer] will be created.
+   */
+  ResolverVisitor(LibraryElement definingLibrary, Source source,
+      TypeProvider typeProvider, AnalysisErrorListener errorListener,
+      {Scope nameScope,
+      InheritanceManager inheritanceManager,
+      StaticTypeAnalyzerFactory typeAnalyzerFactory})
+      : super(definingLibrary, source, typeProvider, errorListener,
+            nameScope: nameScope) {
+    if (inheritanceManager == null) {
+      this._inheritanceManager = new InheritanceManager(definingLibrary);
+    } else {
+      this._inheritanceManager = inheritanceManager;
+    }
+    this.elementResolver = new ElementResolver(this);
+    if (typeAnalyzerFactory == null) {
+      this.typeAnalyzer = new StaticTypeAnalyzer(this);
+    } else {
+      this.typeAnalyzer = typeAnalyzerFactory(this);
+    }
+  }
+
+  /**
+   * Initialize a newly created visitor to resolve the nodes in a compilation unit.
+   *
+   * @param library the library containing the compilation unit being resolved
+   * @param source the source representing the compilation unit being visited
+   * @param typeProvider the object used to access the types from the core library
+   *
+   * Deprecated.  Please use unnamed constructor instead.
+   */
+  @deprecated
+  ResolverVisitor.con1(
+      Library library, Source source, TypeProvider typeProvider,
+      {StaticTypeAnalyzerFactory typeAnalyzerFactory})
+      : this(
+            library.libraryElement, source, typeProvider, library.errorListener,
+            nameScope: library.libraryScope,
+            inheritanceManager: library.inheritanceManager,
+            typeAnalyzerFactory: typeAnalyzerFactory);
+
+  /**
+   * Return the element representing the function containing the current node, or `null` if
+   * the current node is not contained in a function.
+   *
+   * @return the element representing the function containing the current node
+   */
+  ExecutableElement get enclosingFunction => _enclosingFunction;
+
+  /**
+   * Return the object keeping track of which elements have had their types overridden.
+   *
+   * @return the object keeping track of which elements have had their types overridden
+   */
+  TypeOverrideManager get overrideManager => _overrideManager;
+
+  /**
+   * Return the object keeping track of which elements have had their types promoted.
+   *
+   * @return the object keeping track of which elements have had their types promoted
+   */
+  TypePromotionManager get promoteManager => _promoteManager;
+
+  /**
+   * Return the propagated element associated with the given expression whose type can be
+   * overridden, or `null` if there is no element whose type can be overridden.
+   *
+   * @param expression the expression with which the element is associated
+   * @return the element associated with the given expression
+   */
+  VariableElement getOverridablePropagatedElement(Expression expression) {
+    Element element = null;
+    if (expression is SimpleIdentifier) {
+      element = expression.propagatedElement;
+    } else if (expression is PrefixedIdentifier) {
+      element = expression.propagatedElement;
+    } else if (expression is PropertyAccess) {
+      element = expression.propertyName.propagatedElement;
+    }
+    if (element is VariableElement) {
+      return element;
+    }
+    return null;
+  }
+
+  /**
+   * Return the static element associated with the given expression whose type can be overridden, or
+   * `null` if there is no element whose type can be overridden.
+   *
+   * @param expression the expression with which the element is associated
+   * @return the element associated with the given expression
+   */
+  VariableElement getOverridableStaticElement(Expression expression) {
+    Element element = null;
+    if (expression is SimpleIdentifier) {
+      element = expression.staticElement;
+    } else if (expression is PrefixedIdentifier) {
+      element = expression.staticElement;
+    } else if (expression is PropertyAccess) {
+      element = expression.propertyName.staticElement;
+    }
+    if (element is VariableElement) {
+      return element;
+    }
+    return null;
+  }
+
+  /**
+   * Return the static element associated with the given expression whose type can be promoted, or
+   * `null` if there is no element whose type can be promoted.
+   *
+   * @param expression the expression with which the element is associated
+   * @return the element associated with the given expression
+   */
+  VariableElement getPromotionStaticElement(Expression expression) {
+    while (expression is ParenthesizedExpression) {
+      expression = (expression as ParenthesizedExpression).expression;
+    }
+    if (expression is! SimpleIdentifier) {
+      return null;
+    }
+    SimpleIdentifier identifier = expression as SimpleIdentifier;
+    Element element = identifier.staticElement;
+    if (element is! VariableElement) {
+      return null;
+    }
+    ElementKind kind = element.kind;
+    if (kind == ElementKind.LOCAL_VARIABLE) {
+      return element as VariableElement;
+    }
+    if (kind == ElementKind.PARAMETER) {
+      return element as VariableElement;
+    }
+    return null;
+  }
+
+  /**
+   * Prepares this [ResolverVisitor] to using it for incremental resolution.
+   */
+  void initForIncrementalResolution() {
+    _overrideManager.enterScope();
+  }
+
+  /**
+   * If it is appropriate to do so, override the current type of the static and propagated elements
+   * associated with the given expression with the given type. Generally speaking, it is appropriate
+   * if the given type is more specific than the current type.
+   *
+   * @param expression the expression used to access the static and propagated elements whose types
+   *          might be overridden
+   * @param potentialType the potential type of the elements
+   * @param allowPrecisionLoss see @{code overrideVariable} docs
+   */
+  void overrideExpression(Expression expression, DartType potentialType,
+      bool allowPrecisionLoss, bool setExpressionType) {
+    VariableElement element = getOverridableStaticElement(expression);
+    if (element != null) {
+      DartType newBestType =
+          overrideVariable(element, potentialType, allowPrecisionLoss);
+      if (setExpressionType) {
+        recordPropagatedTypeIfBetter(expression, newBestType);
+      }
+    }
+    element = getOverridablePropagatedElement(expression);
+    if (element != null) {
+      overrideVariable(element, potentialType, allowPrecisionLoss);
+    }
+  }
+
+  /**
+   * If it is appropriate to do so, override the current type of the given element with the given
+   * type.
+   *
+   * @param element the element whose type might be overridden
+   * @param potentialType the potential type of the element
+   * @param allowPrecisionLoss true if `potentialType` is allowed to be less precise than the
+   *          current best type
+   *
+   * Return a new better [DartType], or `null` if [potentialType] is not better
+   * than the current [element] type.
+   */
+  DartType overrideVariable(VariableElement element, DartType potentialType,
+      bool allowPrecisionLoss) {
+    if (potentialType == null || potentialType.isBottom) {
+      return null;
+    }
+    DartType currentType = _overrideManager.getBestType(element);
+
+    if (potentialType == currentType) {
+      return null;
+    }
+
+    // If we aren't allowing precision loss then the third and fourth conditions
+    // check that we aren't losing precision.
+    //
+    // Let [C] be the current type and [P] be the potential type.  When we
+    // aren't allowing precision loss -- which is the case for is-checks -- we
+    // check that [! (C << P)] or  [P << C]. The second check, that [P << C], is
+    // analogous to part of the Dart Language Spec rule for type promotion under
+    // is-checks (in the analogy [T] is [P] and [S] is [C]):
+    //
+    //   An is-expression of the form [v is T] shows that [v] has type [T] iff
+    //   [T] is more specific than the type [S] of the expression [v] and both
+    //   [T != dynamic] and [S != dynamic].
+    //
+    // It also covers an important case that is not applicable in the spec:
+    // for union types, we want an is-check to promote from an union type to
+    // (a subtype of) any of its members.
+    //
+    // The first check, that [! (C << P)], covers the case where [P] and [C] are
+    // unrelated types; This case is not addressed in the spec for static types.
+    if (currentType == null ||
+        allowPrecisionLoss ||
+        !currentType.isMoreSpecificThan(potentialType) ||
+        potentialType.isMoreSpecificThan(currentType)) {
+      // TODO(scheglov) type propagation for instance/top-level fields
+      // was disabled because it depends on the order or visiting.
+      // If both field and its client are in the same unit, and we visit
+      // the client before the field, then propagated type is not set yet.
+//      if (element is PropertyInducingElement) {
+//        PropertyInducingElement variable = element;
+//        if (!variable.isConst && !variable.isFinal) {
+//          return;
+//        }
+//        (variable as PropertyInducingElementImpl).propagatedType =
+//            potentialType;
+//      }
+      _overrideManager.setType(element, potentialType);
+      return potentialType;
+    }
+    return null;
+  }
+
+  /**
+   * A client is about to resolve a member in the given class declaration.
+   */
+  void prepareToResolveMembersInClass(ClassDeclaration node) {
+    _enclosingClassDeclaration = node;
+    enclosingClass = node.element;
+    typeAnalyzer.thisType = enclosingClass == null ? null : enclosingClass.type;
+  }
+
+  /**
+   * If the given [type] is valid, strongly more specific than the
+   * existing static type of the given [expression], record it as a propagated
+   * type of the given [expression]. Otherwise, reset it to `null`.
+   *
+   * If [hasOldPropagatedType] is `true` then the existing propagated type
+   * should also is checked.
+   */
+  void recordPropagatedTypeIfBetter(Expression expression, DartType type,
+      [bool hasOldPropagatedType = false]) {
+    // Ensure that propagated type invalid.
+    if (type == null || type.isDynamic || type.isBottom) {
+      if (!hasOldPropagatedType) {
+        expression.propagatedType = null;
+      }
+      return;
+    }
+    // Ensure that propagated type is more specific than the static type.
+    DartType staticType = expression.staticType;
+    if (type == staticType || !type.isMoreSpecificThan(staticType)) {
+      expression.propagatedType = null;
+      return;
+    }
+    // Ensure that the new propagated type is more specific than the old one.
+    if (hasOldPropagatedType) {
+      DartType oldPropagatedType = expression.propagatedType;
+      if (oldPropagatedType != null &&
+          !type.isMoreSpecificThan(oldPropagatedType)) {
+        return;
+      }
+    }
+    // OK
+    expression.propagatedType = type;
+  }
+
+  @override
+  Object visitAnnotation(Annotation node) {
+    AstNode parent = node.parent;
+    if (identical(parent, _enclosingClassDeclaration) ||
+        identical(parent, _enclosingFunctionTypeAlias)) {
+      return null;
+    }
+    return super.visitAnnotation(node);
+  }
+
+  @override
+  Object visitAsExpression(AsExpression node) {
+    super.visitAsExpression(node);
+    // Since an as-statement doesn't actually change the type, we don't
+    // let it affect the propagated type when it would result in a loss
+    // of precision.
+    overrideExpression(node.expression, node.type.type, false, false);
+    return null;
+  }
+
+  @override
+  Object visitAssertStatement(AssertStatement node) {
+    super.visitAssertStatement(node);
+    _propagateTrueState(node.condition);
+    return null;
+  }
+
+  @override
+  Object visitBinaryExpression(BinaryExpression node) {
+    sc.TokenType operatorType = node.operator.type;
+    Expression leftOperand = node.leftOperand;
+    Expression rightOperand = node.rightOperand;
+    if (operatorType == sc.TokenType.AMPERSAND_AMPERSAND) {
+      safelyVisit(leftOperand);
+      if (rightOperand != null) {
+        _overrideManager.enterScope();
+        try {
+          _promoteManager.enterScope();
+          try {
+            _propagateTrueState(leftOperand);
+            // Type promotion.
+            _promoteTypes(leftOperand);
+            _clearTypePromotionsIfPotentiallyMutatedIn(leftOperand);
+            _clearTypePromotionsIfPotentiallyMutatedIn(rightOperand);
+            _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(
+                rightOperand);
+            // Visit right operand.
+            rightOperand.accept(this);
+          } finally {
+            _promoteManager.exitScope();
+          }
+        } finally {
+          _overrideManager.exitScope();
+        }
+      }
+    } else if (operatorType == sc.TokenType.BAR_BAR) {
+      safelyVisit(leftOperand);
+      if (rightOperand != null) {
+        _overrideManager.enterScope();
+        try {
+          _propagateFalseState(leftOperand);
+          rightOperand.accept(this);
+        } finally {
+          _overrideManager.exitScope();
+        }
+      }
+    } else {
+      safelyVisit(leftOperand);
+      safelyVisit(rightOperand);
+    }
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitBlockFunctionBody(BlockFunctionBody node) {
+    safelyVisit(_commentBeforeFunction);
+    _overrideManager.enterScope();
+    try {
+      super.visitBlockFunctionBody(node);
+    } finally {
+      _overrideManager.exitScope();
+    }
+    return null;
+  }
+
+  @override
+  Object visitBreakStatement(BreakStatement node) {
+    //
+    // We do not visit the label because it needs to be visited in the context
+    // of the statement.
+    //
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitClassDeclaration(ClassDeclaration node) {
+    //
+    // Resolve the metadata in the library scope.
+    //
+    if (node.metadata != null) {
+      node.metadata.accept(this);
+    }
+    _enclosingClassDeclaration = node;
+    //
+    // Continue the class resolution.
+    //
+    ClassElement outerType = enclosingClass;
+    try {
+      enclosingClass = node.element;
+      typeAnalyzer.thisType =
+          enclosingClass == null ? null : enclosingClass.type;
+      super.visitClassDeclaration(node);
+      node.accept(elementResolver);
+      node.accept(typeAnalyzer);
+    } finally {
+      typeAnalyzer.thisType = outerType == null ? null : outerType.type;
+      enclosingClass = outerType;
+      _enclosingClassDeclaration = null;
+    }
+    return null;
+  }
+
+  /**
+   * Implementation of this method should be synchronized with
+   * [visitClassDeclaration].
+   */
+  visitClassDeclarationIncrementally(ClassDeclaration node) {
+    //
+    // Resolve the metadata in the library scope.
+    //
+    if (node.metadata != null) {
+      node.metadata.accept(this);
+    }
+    _enclosingClassDeclaration = node;
+    //
+    // Continue the class resolution.
+    //
+    enclosingClass = node.element;
+    typeAnalyzer.thisType = enclosingClass == null ? null : enclosingClass.type;
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+  }
+
+  @override
+  Object visitComment(Comment node) {
+    if (node.parent is FunctionDeclaration ||
+        node.parent is ConstructorDeclaration ||
+        node.parent is MethodDeclaration) {
+      if (!identical(node, _commentBeforeFunction)) {
+        _commentBeforeFunction = node;
+        return null;
+      }
+    }
+    super.visitComment(node);
+    _commentBeforeFunction = null;
+    return null;
+  }
+
+  @override
+  Object visitCommentReference(CommentReference node) {
+    //
+    // We do not visit the identifier because it needs to be visited in the
+    // context of the reference.
+    //
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitCompilationUnit(CompilationUnit node) {
+    //
+    // TODO(brianwilkerson) The goal of the code below is to visit the
+    // declarations in such an order that we can infer type information for
+    // top-level variables before we visit references to them. This is better
+    // than making no effort, but still doesn't completely satisfy that goal
+    // (consider for example "final var a = b; final var b = 0;"; we'll infer a
+    // type of 'int' for 'b', but not for 'a' because of the order of the
+    // visits). Ideally we would create a dependency graph, but that would
+    // require references to be resolved, which they are not.
+    //
+    _overrideManager.enterScope();
+    try {
+      NodeList<Directive> directives = node.directives;
+      int directiveCount = directives.length;
+      for (int i = 0; i < directiveCount; i++) {
+        directives[i].accept(this);
+      }
+      NodeList<CompilationUnitMember> declarations = node.declarations;
+      int declarationCount = declarations.length;
+      for (int i = 0; i < declarationCount; i++) {
+        CompilationUnitMember declaration = declarations[i];
+        if (declaration is! ClassDeclaration) {
+          declaration.accept(this);
+        }
+      }
+      for (int i = 0; i < declarationCount; i++) {
+        CompilationUnitMember declaration = declarations[i];
+        if (declaration is ClassDeclaration) {
+          declaration.accept(this);
+        }
+      }
+    } finally {
+      _overrideManager.exitScope();
+    }
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitConditionalExpression(ConditionalExpression node) {
+    Expression condition = node.condition;
+    safelyVisit(condition);
+    Expression thenExpression = node.thenExpression;
+    if (thenExpression != null) {
+      _overrideManager.enterScope();
+      try {
+        _promoteManager.enterScope();
+        try {
+          _propagateTrueState(condition);
+          // Type promotion.
+          _promoteTypes(condition);
+          _clearTypePromotionsIfPotentiallyMutatedIn(thenExpression);
+          _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(
+              thenExpression);
+          // Visit "then" expression.
+          thenExpression.accept(this);
+        } finally {
+          _promoteManager.exitScope();
+        }
+      } finally {
+        _overrideManager.exitScope();
+      }
+    }
+    Expression elseExpression = node.elseExpression;
+    if (elseExpression != null) {
+      _overrideManager.enterScope();
+      try {
+        _propagateFalseState(condition);
+        elseExpression.accept(this);
+      } finally {
+        _overrideManager.exitScope();
+      }
+    }
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    bool thenIsAbrupt = _isAbruptTerminationExpression(thenExpression);
+    bool elseIsAbrupt = _isAbruptTerminationExpression(elseExpression);
+    if (elseIsAbrupt && !thenIsAbrupt) {
+      _propagateTrueState(condition);
+      _propagateState(thenExpression);
+    } else if (thenIsAbrupt && !elseIsAbrupt) {
+      _propagateFalseState(condition);
+      _propagateState(elseExpression);
+    }
+    return null;
+  }
+
+  @override
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    ExecutableElement outerFunction = _enclosingFunction;
+    try {
+      _enclosingFunction = node.element;
+      super.visitConstructorDeclaration(node);
+    } finally {
+      _enclosingFunction = outerFunction;
+    }
+    ConstructorElementImpl constructor = node.element;
+    constructor.constantInitializers =
+        new ConstantAstCloner().cloneNodeList(node.initializers);
+    return null;
+  }
+
+  @override
+  Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
+    //
+    // We visit the expression, but do not visit the field name because it needs
+    // to be visited in the context of the constructor field initializer node.
+    //
+    safelyVisit(node.expression);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitConstructorName(ConstructorName node) {
+    //
+    // We do not visit either the type name, because it won't be visited anyway,
+    // or the name, because it needs to be visited in the context of the
+    // constructor name.
+    //
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitContinueStatement(ContinueStatement node) {
+    //
+    // We do not visit the label because it needs to be visited in the context
+    // of the statement.
+    //
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitDefaultFormalParameter(DefaultFormalParameter node) {
+    super.visitDefaultFormalParameter(node);
+    ParameterElement element = node.element;
+    if (element.initializer != null && node.defaultValue != null) {
+      (element.initializer as FunctionElementImpl).returnType =
+          node.defaultValue.staticType;
+    }
+    FormalParameterList parent = node.parent;
+    AstNode grandparent = parent.parent;
+    if (grandparent is ConstructorDeclaration &&
+        grandparent.constKeyword != null) {
+      // For const constructors, we need to clone the ASTs for default formal
+      // parameters, so that we can use them during constant evaluation.
+      ParameterElement element = node.element;
+      (element as ConstVariableElement).constantInitializer =
+          new ConstantAstCloner().cloneNode(node.defaultValue);
+    }
+    return null;
+  }
+
+  @override
+  Object visitDoStatement(DoStatement node) {
+    _overrideManager.enterScope();
+    try {
+      super.visitDoStatement(node);
+    } finally {
+      _overrideManager.exitScope();
+    }
+    // TODO(brianwilkerson) If the loop can only be exited because the condition
+    // is false, then propagateFalseState(node.getCondition());
+    return null;
+  }
+
+  @override
+  Object visitEmptyFunctionBody(EmptyFunctionBody node) {
+    safelyVisit(_commentBeforeFunction);
+    if (resolveOnlyCommentInFunctionBody) {
+      return null;
+    }
+    return super.visitEmptyFunctionBody(node);
+  }
+
+  @override
+  Object visitEnumDeclaration(EnumDeclaration node) {
+    //
+    // Resolve the metadata in the library scope
+    // and associate the annotations with the element.
+    //
+    if (node.metadata != null) {
+      node.metadata.accept(this);
+      ElementResolver.setMetadata(node.element, node);
+    }
+    //
+    // Continue the enum resolution.
+    //
+    ClassElement outerType = enclosingClass;
+    try {
+      enclosingClass = node.element;
+      typeAnalyzer.thisType =
+          enclosingClass == null ? null : enclosingClass.type;
+      super.visitEnumDeclaration(node);
+      node.accept(elementResolver);
+      node.accept(typeAnalyzer);
+    } finally {
+      typeAnalyzer.thisType = outerType == null ? null : outerType.type;
+      enclosingClass = outerType;
+      _enclosingClassDeclaration = null;
+    }
+    return null;
+  }
+
+  @override
+  Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
+    safelyVisit(_commentBeforeFunction);
+    if (resolveOnlyCommentInFunctionBody) {
+      return null;
+    }
+    _overrideManager.enterScope();
+    try {
+      super.visitExpressionFunctionBody(node);
+    } finally {
+      _overrideManager.exitScope();
+    }
+    return null;
+  }
+
+  @override
+  Object visitFieldDeclaration(FieldDeclaration node) {
+    _overrideManager.enterScope();
+    try {
+      super.visitFieldDeclaration(node);
+    } finally {
+      Map<VariableElement, DartType> overrides =
+          _overrideManager.captureOverrides(node.fields);
+      _overrideManager.exitScope();
+      _overrideManager.applyOverrides(overrides);
+    }
+    return null;
+  }
+
+  @override
+  Object visitForEachStatement(ForEachStatement node) {
+    _overrideManager.enterScope();
+    try {
+      super.visitForEachStatement(node);
+    } finally {
+      _overrideManager.exitScope();
+    }
+    return null;
+  }
+
+  @override
+  void visitForEachStatementInScope(ForEachStatement node) {
+    //
+    // We visit the iterator before the loop variable because the loop variable
+    // cannot be in scope while visiting the iterator.
+    //
+    Expression iterable = node.iterable;
+    safelyVisit(iterable);
+    DeclaredIdentifier loopVariable = node.loopVariable;
+    SimpleIdentifier identifier = node.identifier;
+    safelyVisit(loopVariable);
+    safelyVisit(identifier);
+    Statement body = node.body;
+    if (body != null) {
+      _overrideManager.enterScope();
+      try {
+        if (loopVariable != null && iterable != null) {
+          LocalVariableElement loopElement = loopVariable.element;
+          if (loopElement != null) {
+            DartType propagatedType = null;
+            if (node.awaitKeyword == null) {
+              propagatedType = _getIteratorElementType(iterable);
+            } else {
+              propagatedType = _getStreamElementType(iterable);
+            }
+            if (propagatedType != null) {
+              overrideVariable(loopElement, propagatedType, true);
+              _recordPropagatedType(loopVariable.identifier, propagatedType);
+            }
+          }
+        } else if (identifier != null && iterable != null) {
+          Element identifierElement = identifier.staticElement;
+          if (identifierElement is VariableElement) {
+            DartType iteratorElementType = _getIteratorElementType(iterable);
+            overrideVariable(identifierElement, iteratorElementType, true);
+            _recordPropagatedType(identifier, iteratorElementType);
+          }
+        }
+        visitStatementInScope(body);
+      } finally {
+        _overrideManager.exitScope();
+      }
+    }
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+  }
+
+  @override
+  Object visitForStatement(ForStatement node) {
+    _overrideManager.enterScope();
+    try {
+      super.visitForStatement(node);
+    } finally {
+      _overrideManager.exitScope();
+    }
+    return null;
+  }
+
+  @override
+  void visitForStatementInScope(ForStatement node) {
+    safelyVisit(node.variables);
+    safelyVisit(node.initialization);
+    safelyVisit(node.condition);
+    _overrideManager.enterScope();
+    try {
+      _propagateTrueState(node.condition);
+      visitStatementInScope(node.body);
+      node.updaters.accept(this);
+    } finally {
+      _overrideManager.exitScope();
+    }
+    // TODO(brianwilkerson) If the loop can only be exited because the condition
+    // is false, then propagateFalseState(condition);
+  }
+
+  @override
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    ExecutableElement outerFunction = _enclosingFunction;
+    try {
+      SimpleIdentifier functionName = node.name;
+      _enclosingFunction = functionName.staticElement as ExecutableElement;
+      super.visitFunctionDeclaration(node);
+    } finally {
+      _enclosingFunction = outerFunction;
+    }
+    return null;
+  }
+
+  @override
+  Object visitFunctionExpression(FunctionExpression node) {
+    ExecutableElement outerFunction = _enclosingFunction;
+    try {
+      _enclosingFunction = node.element;
+      _overrideManager.enterScope();
+      try {
+        super.visitFunctionExpression(node);
+      } finally {
+        _overrideManager.exitScope();
+      }
+    } finally {
+      _enclosingFunction = outerFunction;
+    }
+    return null;
+  }
+
+  @override
+  Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
+    safelyVisit(node.function);
+    node.accept(elementResolver);
+    _inferFunctionExpressionsParametersTypes(node.argumentList);
+    safelyVisit(node.argumentList);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+    // Resolve the metadata in the library scope.
+    if (node.metadata != null) {
+      node.metadata.accept(this);
+    }
+    FunctionTypeAlias outerAlias = _enclosingFunctionTypeAlias;
+    _enclosingFunctionTypeAlias = node;
+    try {
+      super.visitFunctionTypeAlias(node);
+    } finally {
+      _enclosingFunctionTypeAlias = outerAlias;
+    }
+    return null;
+  }
+
+  @override
+  Object visitHideCombinator(HideCombinator node) => null;
+
+  @override
+  Object visitIfStatement(IfStatement node) {
+    Expression condition = node.condition;
+    safelyVisit(condition);
+    Map<VariableElement, DartType> thenOverrides =
+        new HashMap<VariableElement, DartType>();
+    Statement thenStatement = node.thenStatement;
+    if (thenStatement != null) {
+      _overrideManager.enterScope();
+      try {
+        _promoteManager.enterScope();
+        try {
+          _propagateTrueState(condition);
+          // Type promotion.
+          _promoteTypes(condition);
+          _clearTypePromotionsIfPotentiallyMutatedIn(thenStatement);
+          _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(
+              thenStatement);
+          // Visit "then".
+          visitStatementInScope(thenStatement);
+        } finally {
+          _promoteManager.exitScope();
+        }
+      } finally {
+        thenOverrides = _overrideManager.captureLocalOverrides();
+        _overrideManager.exitScope();
+      }
+    }
+    Map<VariableElement, DartType> elseOverrides =
+        new HashMap<VariableElement, DartType>();
+    Statement elseStatement = node.elseStatement;
+    if (elseStatement != null) {
+      _overrideManager.enterScope();
+      try {
+        _propagateFalseState(condition);
+        visitStatementInScope(elseStatement);
+      } finally {
+        elseOverrides = _overrideManager.captureLocalOverrides();
+        _overrideManager.exitScope();
+      }
+    }
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    // Join overrides.
+    bool thenIsAbrupt = _isAbruptTerminationStatement(thenStatement);
+    bool elseIsAbrupt = _isAbruptTerminationStatement(elseStatement);
+    if (elseIsAbrupt && !thenIsAbrupt) {
+      _propagateTrueState(condition);
+      _overrideManager.applyOverrides(thenOverrides);
+    } else if (thenIsAbrupt && !elseIsAbrupt) {
+      _propagateFalseState(condition);
+      _overrideManager.applyOverrides(elseOverrides);
+    } else if (!thenIsAbrupt && !elseIsAbrupt) {
+      List<Map<VariableElement, DartType>> perBranchOverrides =
+          new List<Map<VariableElement, DartType>>();
+      perBranchOverrides.add(thenOverrides);
+      perBranchOverrides.add(elseOverrides);
+      _overrideManager.mergeOverrides(perBranchOverrides);
+    }
+    return null;
+  }
+
+  @override
+  Object visitLabel(Label node) => null;
+
+  @override
+  Object visitLibraryIdentifier(LibraryIdentifier node) => null;
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement outerFunction = _enclosingFunction;
+    try {
+      _enclosingFunction = node.element;
+      super.visitMethodDeclaration(node);
+    } finally {
+      _enclosingFunction = outerFunction;
+    }
+    return null;
+  }
+
+  @override
+  Object visitMethodInvocation(MethodInvocation node) {
+    //
+    // We visit the target and argument list, but do not visit the method name
+    // because it needs to be visited in the context of the invocation.
+    //
+    safelyVisit(node.target);
+    node.accept(elementResolver);
+    _inferFunctionExpressionsParametersTypes(node.argumentList);
+    safelyVisit(node.argumentList);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitNode(AstNode node) {
+    node.visitChildren(this);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitPrefixedIdentifier(PrefixedIdentifier node) {
+    //
+    // We visit the prefix, but do not visit the identifier because it needs to
+    // be visited in the context of the prefix.
+    //
+    safelyVisit(node.prefix);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitPropertyAccess(PropertyAccess node) {
+    //
+    // We visit the target, but do not visit the property name because it needs
+    // to be visited in the context of the property access node.
+    //
+    safelyVisit(node.target);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
+    //
+    // We visit the argument list, but do not visit the optional identifier
+    // because it needs to be visited in the context of the constructor
+    // invocation.
+    //
+    safelyVisit(node.argumentList);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitShowCombinator(ShowCombinator node) => null;
+
+  @override
+  Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
+    //
+    // We visit the argument list, but do not visit the optional identifier
+    // because it needs to be visited in the context of the constructor
+    // invocation.
+    //
+    safelyVisit(node.argumentList);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  @override
+  Object visitSwitchCase(SwitchCase node) {
+    _overrideManager.enterScope();
+    try {
+      super.visitSwitchCase(node);
+    } finally {
+      _overrideManager.exitScope();
+    }
+    return null;
+  }
+
+  @override
+  Object visitSwitchDefault(SwitchDefault node) {
+    _overrideManager.enterScope();
+    try {
+      super.visitSwitchDefault(node);
+    } finally {
+      _overrideManager.exitScope();
+    }
+    return null;
+  }
+
+  @override
+  Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+    _overrideManager.enterScope();
+    try {
+      super.visitTopLevelVariableDeclaration(node);
+    } finally {
+      Map<VariableElement, DartType> overrides =
+          _overrideManager.captureOverrides(node.variables);
+      _overrideManager.exitScope();
+      _overrideManager.applyOverrides(overrides);
+    }
+    return null;
+  }
+
+  @override
+  Object visitTypeName(TypeName node) => null;
+
+  @override
+  Object visitVariableDeclaration(VariableDeclaration node) {
+    super.visitVariableDeclaration(node);
+    VariableElement element = node.element;
+    if (element.initializer != null && node.initializer != null) {
+      (element.initializer as FunctionElementImpl).returnType =
+          node.initializer.staticType;
+    }
+    // Note: in addition to cloning the initializers for const variables, we
+    // have to clone the initializers for non-static final fields (because if
+    // they occur in a class with a const constructor, they will be needed to
+    // evaluate the const constructor).
+    if ((element.isConst ||
+            (element is FieldElement &&
+                element.isFinal &&
+                !element.isStatic)) &&
+        node.initializer != null) {
+      (element as ConstVariableElement).constantInitializer =
+          new ConstantAstCloner().cloneNode(node.initializer);
+    }
+    return null;
+  }
+
+  @override
+  Object visitWhileStatement(WhileStatement node) {
+    // Note: since we don't call the base class, we have to maintain
+    // _implicitLabelScope ourselves.
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
+    try {
+      _implicitLabelScope = _implicitLabelScope.nest(node);
+      Expression condition = node.condition;
+      safelyVisit(condition);
+      Statement body = node.body;
+      if (body != null) {
+        _overrideManager.enterScope();
+        try {
+          _propagateTrueState(condition);
+          visitStatementInScope(body);
+        } finally {
+          _overrideManager.exitScope();
+        }
+      }
+    } finally {
+      _implicitLabelScope = outerImplicitScope;
+    }
+    // TODO(brianwilkerson) If the loop can only be exited because the condition
+    // is false, then propagateFalseState(condition);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
+    return null;
+  }
+
+  /**
+   * Checks each promoted variable in the current scope for compliance with the following
+   * specification statement:
+   *
+   * If the variable <i>v</i> is accessed by a closure in <i>s<sub>1</sub></i> then the variable
+   * <i>v</i> is not potentially mutated anywhere in the scope of <i>v</i>.
+   */
+  void _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(
+      AstNode target) {
+    for (Element element in _promoteManager.promotedElements) {
+      if ((element as VariableElementImpl).isPotentiallyMutatedInScope) {
+        if (_isVariableAccessedInClosure(element, target)) {
+          _promoteManager.setType(element, null);
+        }
+      }
+    }
+  }
+
+  /**
+   * Checks each promoted variable in the current scope for compliance with the following
+   * specification statement:
+   *
+   * <i>v</i> is not potentially mutated in <i>s<sub>1</sub></i> or within a closure.
+   */
+  void _clearTypePromotionsIfPotentiallyMutatedIn(AstNode target) {
+    for (Element element in _promoteManager.promotedElements) {
+      if (_isVariablePotentiallyMutatedIn(element, target)) {
+        _promoteManager.setType(element, null);
+      }
+    }
+  }
+
+  /**
+   * The given expression is the expression used to compute the iterator for a
+   * for-each statement. Attempt to compute the type of objects that will be
+   * assigned to the loop variable and return that type. Return `null` if the
+   * type could not be determined. The [iteratorExpression] is the expression
+   * that will return the Iterable being iterated over.
+   */
+  DartType _getIteratorElementType(Expression iteratorExpression) {
+    DartType expressionType = iteratorExpression.bestType;
+    if (expressionType is InterfaceType) {
+      InterfaceType interfaceType = expressionType;
+      FunctionType iteratorFunction =
+          _inheritanceManager.lookupMemberType(interfaceType, "iterator");
+      if (iteratorFunction == null) {
+        // TODO(brianwilkerson) Should we report this error?
+        return null;
+      }
+      DartType iteratorType = iteratorFunction.returnType;
+      if (iteratorType is InterfaceType) {
+        InterfaceType iteratorInterfaceType = iteratorType;
+        FunctionType currentFunction = _inheritanceManager.lookupMemberType(
+            iteratorInterfaceType, "current");
+        if (currentFunction == null) {
+          // TODO(brianwilkerson) Should we report this error?
+          return null;
+        }
+        return currentFunction.returnType;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * The given expression is the expression used to compute the stream for an
+   * asyncronous for-each statement. Attempt to compute the type of objects that
+   * will be assigned to the loop variable and return that type. Return `null`
+   * if the type could not be determined. The [streamExpression] is the
+   * expression that will return the stream being iterated over.
+   */
+  DartType _getStreamElementType(Expression streamExpression) {
+    DartType streamType = streamExpression.bestType;
+    if (streamType is InterfaceType) {
+      FunctionType listenFunction =
+          _inheritanceManager.lookupMemberType(streamType, "listen");
+      if (listenFunction == null) {
+        return null;
+      }
+      List<ParameterElement> listenParameters = listenFunction.parameters;
+      if (listenParameters == null || listenParameters.length < 1) {
+        return null;
+      }
+      DartType onDataType = listenParameters[0].type;
+      if (onDataType is FunctionType) {
+        List<ParameterElement> onDataParameters = onDataType.parameters;
+        if (onDataParameters == null || onDataParameters.length < 1) {
+          return null;
+        }
+        DartType eventType = onDataParameters[0].type;
+        // TODO(paulberry): checking that typeParameters.isNotEmpty is a
+        // band-aid fix for dartbug.com/24191.  Figure out what the correct
+        // logic should be.
+        if (streamType.typeParameters.isNotEmpty &&
+            eventType.element == streamType.typeParameters[0]) {
+          return streamType.typeArguments[0];
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * If given "mayBeClosure" is [FunctionExpression] without explicit parameters types and its
+   * required type is [FunctionType], then infer parameters types from [FunctionType].
+   */
+  void _inferFunctionExpressionParametersTypes(
+      Expression mayBeClosure, DartType mayByFunctionType) {
+    // prepare closure
+    if (mayBeClosure is! FunctionExpression) {
+      return;
+    }
+    FunctionExpression closure = mayBeClosure as FunctionExpression;
+    // prepare expected closure type
+    if (mayByFunctionType is! FunctionType) {
+      return;
+    }
+    FunctionType expectedClosureType = mayByFunctionType as FunctionType;
+    // If the expectedClosureType is not more specific than the static type,
+    // return.
+    DartType staticClosureType =
+        closure.element != null ? closure.element.type : null;
+    if (staticClosureType != null &&
+        !expectedClosureType.isMoreSpecificThan(staticClosureType)) {
+      return;
+    }
+    // set propagated type for the closure
+    closure.propagatedType = expectedClosureType;
+    // set inferred types for parameters
+    NodeList<FormalParameter> parameters = closure.parameters.parameters;
+    List<ParameterElement> expectedParameters = expectedClosureType.parameters;
+    for (int i = 0;
+        i < parameters.length && i < expectedParameters.length;
+        i++) {
+      FormalParameter parameter = parameters[i];
+      ParameterElement element = parameter.element;
+      DartType currentType = _overrideManager.getBestType(element);
+      // may be override the type
+      DartType expectedType = expectedParameters[i].type;
+      if (currentType == null || expectedType.isMoreSpecificThan(currentType)) {
+        _overrideManager.setType(element, expectedType);
+      }
+    }
+  }
+
+  /**
+   * Try to infer types of parameters of the [FunctionExpression] arguments.
+   */
+  void _inferFunctionExpressionsParametersTypes(ArgumentList argumentList) {
+    for (Expression argument in argumentList.arguments) {
+      ParameterElement parameter = argument.propagatedParameterElement;
+      if (parameter == null) {
+        parameter = argument.staticParameterElement;
+      }
+      if (parameter != null) {
+        _inferFunctionExpressionParametersTypes(argument, parameter.type);
+      }
+    }
+  }
+
+  /**
+   * Return `true` if the given expression terminates abruptly (that is, if any expression
+   * following the given expression will not be reached).
+   *
+   * @param expression the expression being tested
+   * @return `true` if the given expression terminates abruptly
+   */
+  bool _isAbruptTerminationExpression(Expression expression) {
+    // TODO(brianwilkerson) This needs to be significantly improved. Ideally we
+    // would eventually turn this into a method on Expression that returns a
+    // termination indication (normal, abrupt with no exception, abrupt with an
+    // exception).
+    while (expression is ParenthesizedExpression) {
+      expression = (expression as ParenthesizedExpression).expression;
+    }
+    return expression is ThrowExpression || expression is RethrowExpression;
+  }
+
+  /**
+   * Return `true` if the given statement terminates abruptly (that is, if any statement
+   * following the given statement will not be reached).
+   *
+   * @param statement the statement being tested
+   * @return `true` if the given statement terminates abruptly
+   */
+  bool _isAbruptTerminationStatement(Statement statement) {
+    // TODO(brianwilkerson) This needs to be significantly improved. Ideally we
+    // would eventually turn this into a method on Statement that returns a
+    // termination indication (normal, abrupt with no exception, abrupt with an
+    // exception).
+    //
+    // collinsn: it is unsound to assume that [break] and [continue] are
+    // "abrupt". See: https://code.google.com/p/dart/issues/detail?id=19929#c4
+    // (tests are included in TypePropagationTest.java).
+    // In general, the difficulty is loopy control flow.
+    //
+    // In the presence of exceptions things become much more complicated, but
+    // while we only use this to propagate at [if]-statement join points,
+    // checking for [return] may work well enough in the common case.
+    if (statement is ReturnStatement) {
+      return true;
+    } else if (statement is ExpressionStatement) {
+      return _isAbruptTerminationExpression(statement.expression);
+    } else if (statement is Block) {
+      NodeList<Statement> statements = statement.statements;
+      int size = statements.length;
+      if (size == 0) {
+        return false;
+      }
+
+      // This last-statement-is-return heuristic is unsound for adversarial
+      // code, but probably works well in the common case:
+      //
+      //   var x = 123;
+      //   var c = true;
+      //   L: if (c) {
+      //     x = "hello";
+      //     c = false;
+      //     break L;
+      //     return;
+      //   }
+      //   print(x);
+      //
+      // Unsound to assume that [x = "hello";] never executed after the
+      // if-statement. Of course, a dead-code analysis could point out that
+      // [return] here is dead.
+      return _isAbruptTerminationStatement(statements[size - 1]);
+    }
+    return false;
+  }
+
+  /**
+   * Return `true` if the given variable is accessed within a closure in the given
+   * [AstNode] and also mutated somewhere in variable scope. This information is only
+   * available for local variables (including parameters).
+   *
+   * @param variable the variable to check
+   * @param target the [AstNode] to check within
+   * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
+   */
+  bool _isVariableAccessedInClosure(Element variable, AstNode target) {
+    _ResolverVisitor_isVariableAccessedInClosure visitor =
+        new _ResolverVisitor_isVariableAccessedInClosure(variable);
+    target.accept(visitor);
+    return visitor.result;
+  }
+
+  /**
+   * Return `true` if the given variable is potentially mutated somewhere in the given
+   * [AstNode]. This information is only available for local variables (including parameters).
+   *
+   * @param variable the variable to check
+   * @param target the [AstNode] to check within
+   * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
+   */
+  bool _isVariablePotentiallyMutatedIn(Element variable, AstNode target) {
+    _ResolverVisitor_isVariablePotentiallyMutatedIn visitor =
+        new _ResolverVisitor_isVariablePotentiallyMutatedIn(variable);
+    target.accept(visitor);
+    return visitor.result;
+  }
+
+  /**
+   * If it is appropriate to do so, promotes the current type of the static element associated with
+   * the given expression with the given type. Generally speaking, it is appropriate if the given
+   * type is more specific than the current type.
+   *
+   * @param expression the expression used to access the static element whose types might be
+   *          promoted
+   * @param potentialType the potential type of the elements
+   */
+  void _promote(Expression expression, DartType potentialType) {
+    VariableElement element = getPromotionStaticElement(expression);
+    if (element != null) {
+      // may be mutated somewhere in closure
+      if (element.isPotentiallyMutatedInClosure) {
+        return;
+      }
+      // prepare current variable type
+      DartType type = _promoteManager.getType(element);
+      if (type == null) {
+        type = expression.staticType;
+      }
+      // Declared type should not be "dynamic".
+      if (type == null || type.isDynamic) {
+        return;
+      }
+      // Promoted type should not be "dynamic".
+      if (potentialType == null || potentialType.isDynamic) {
+        return;
+      }
+      // Promoted type should be more specific than declared.
+      if (!potentialType.isMoreSpecificThan(type)) {
+        return;
+      }
+      // Do promote type of variable.
+      _promoteManager.setType(element, potentialType);
+    }
+  }
+
+  /**
+   * Promotes type information using given condition.
+   */
+  void _promoteTypes(Expression condition) {
+    if (condition is BinaryExpression) {
+      BinaryExpression binary = condition;
+      if (binary.operator.type == sc.TokenType.AMPERSAND_AMPERSAND) {
+        Expression left = binary.leftOperand;
+        Expression right = binary.rightOperand;
+        _promoteTypes(left);
+        _promoteTypes(right);
+        _clearTypePromotionsIfPotentiallyMutatedIn(right);
+      }
+    } else if (condition is IsExpression) {
+      IsExpression is2 = condition;
+      if (is2.notOperator == null) {
+        _promote(is2.expression, is2.type.type);
+      }
+    } else if (condition is ParenthesizedExpression) {
+      _promoteTypes(condition.expression);
+    }
+  }
+
+  /**
+   * Propagate any type information that results from knowing that the given condition will have
+   * been evaluated to 'false'.
+   *
+   * @param condition the condition that will have evaluated to 'false'
+   */
+  void _propagateFalseState(Expression condition) {
+    if (condition is BinaryExpression) {
+      BinaryExpression binary = condition;
+      if (binary.operator.type == sc.TokenType.BAR_BAR) {
+        _propagateFalseState(binary.leftOperand);
+        _propagateFalseState(binary.rightOperand);
+      }
+    } else if (condition is IsExpression) {
+      IsExpression is2 = condition;
+      if (is2.notOperator != null) {
+        // Since an is-statement doesn't actually change the type, we don't
+        // let it affect the propagated type when it would result in a loss
+        // of precision.
+        overrideExpression(is2.expression, is2.type.type, false, false);
+      }
+    } else if (condition is PrefixExpression) {
+      PrefixExpression prefix = condition;
+      if (prefix.operator.type == sc.TokenType.BANG) {
+        _propagateTrueState(prefix.operand);
+      }
+    } else if (condition is ParenthesizedExpression) {
+      _propagateFalseState(condition.expression);
+    }
+  }
+
+  /**
+   * Propagate any type information that results from knowing that the given expression will have
+   * been evaluated without altering the flow of execution.
+   *
+   * @param expression the expression that will have been evaluated
+   */
+  void _propagateState(Expression expression) {
+    // TODO(brianwilkerson) Implement this.
+  }
+
+  /**
+   * Propagate any type information that results from knowing that the given condition will have
+   * been evaluated to 'true'.
+   *
+   * @param condition the condition that will have evaluated to 'true'
+   */
+  void _propagateTrueState(Expression condition) {
+    if (condition is BinaryExpression) {
+      BinaryExpression binary = condition;
+      if (binary.operator.type == sc.TokenType.AMPERSAND_AMPERSAND) {
+        _propagateTrueState(binary.leftOperand);
+        _propagateTrueState(binary.rightOperand);
+      }
+    } else if (condition is IsExpression) {
+      IsExpression is2 = condition;
+      if (is2.notOperator == null) {
+        // Since an is-statement doesn't actually change the type, we don't
+        // let it affect the propagated type when it would result in a loss
+        // of precision.
+        overrideExpression(is2.expression, is2.type.type, false, false);
+      }
+    } else if (condition is PrefixExpression) {
+      PrefixExpression prefix = condition;
+      if (prefix.operator.type == sc.TokenType.BANG) {
+        _propagateFalseState(prefix.operand);
+      }
+    } else if (condition is ParenthesizedExpression) {
+      _propagateTrueState(condition.expression);
+    }
+  }
+
+  /**
+   * Record that the propagated type of the given node is the given type.
+   *
+   * @param expression the node whose type is to be recorded
+   * @param type the propagated type of the node
+   */
+  void _recordPropagatedType(Expression expression, DartType type) {
+    if (type != null && !type.isDynamic) {
+      expression.propagatedType = type;
+    }
+  }
+}
+
+/**
+ * The abstract class `Scope` defines the behavior common to name scopes used by the resolver
+ * to determine which names are visible at any given point in the code.
+ */
+abstract class Scope {
+  /**
+   * The prefix used to mark an identifier as being private to its library.
+   */
+  static int PRIVATE_NAME_PREFIX = 0x5F;
+
+  /**
+   * The suffix added to the declared name of a setter when looking up the setter. Used to
+   * disambiguate between a getter and a setter that have the same name.
+   */
+  static String SETTER_SUFFIX = "=";
+
+  /**
+   * The name used to look up the method used to implement the unary minus operator. Used to
+   * disambiguate between the unary and binary operators.
+   */
+  static String UNARY_MINUS = "unary-";
+
+  /**
+   * A table mapping names that are defined in this scope to the element representing the thing
+   * declared with that name.
+   */
+  HashMap<String, Element> _definedNames = new HashMap<String, Element>();
+
+  /**
+   * A flag indicating whether there are any names defined in this scope.
+   */
+  bool _hasName = false;
+
+  /**
+   * Return the scope in which this scope is lexically enclosed.
+   *
+   * @return the scope in which this scope is lexically enclosed
+   */
+  Scope get enclosingScope => null;
+
+  /**
+   * Return the listener that is to be informed when an error is encountered.
+   *
+   * @return the listener that is to be informed when an error is encountered
+   */
+  AnalysisErrorListener get errorListener;
+
+  /**
+   * Add the given element to this scope. If there is already an element with the given name defined
+   * in this scope, then an error will be generated and the original element will continue to be
+   * mapped to the name. If there is an element with the given name in an enclosing scope, then a
+   * warning will be generated but the given element will hide the inherited element.
+   *
+   * @param element the element to be added to this scope
+   */
+  void define(Element element) {
+    String name = _getName(element);
+    if (name != null && !name.isEmpty) {
+      if (_definedNames.containsKey(name)) {
+        errorListener
+            .onError(getErrorForDuplicate(_definedNames[name], element));
+      } else {
+        _definedNames[name] = element;
+        _hasName = true;
+      }
+    }
+  }
+
+  /**
+   * Add the given element to this scope without checking for duplication or hiding.
+   *
+   * @param name the name of the element to be added
+   * @param element the element to be added to this scope
+   */
+  void defineNameWithoutChecking(String name, Element element) {
+    _definedNames[name] = element;
+    _hasName = true;
+  }
+
+  /**
+   * Add the given element to this scope without checking for duplication or hiding.
+   *
+   * @param element the element to be added to this scope
+   */
+  void defineWithoutChecking(Element element) {
+    _definedNames[_getName(element)] = element;
+    _hasName = true;
+  }
+
+  /**
+   * Return the error code to be used when reporting that a name being defined locally conflicts
+   * with another element of the same name in the local scope.
+   *
+   * @param existing the first element to be declared with the conflicting name
+   * @param duplicate another element declared with the conflicting name
+   * @return the error code used to report duplicate names within a scope
+   */
+  AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
+    // TODO(brianwilkerson) Customize the error message based on the types of
+    // elements that share the same name.
+    // TODO(jwren) There are 4 error codes for duplicate, but only 1 is being
+    // generated.
+    Source source = duplicate.source;
+    return new AnalysisError(
+        source,
+        duplicate.nameOffset,
+        duplicate.displayName.length,
+        CompileTimeErrorCode.DUPLICATE_DEFINITION,
+        [existing.displayName]);
+  }
+
+  /**
+   * Return the source that contains the given identifier, or the source associated with this scope
+   * if the source containing the identifier could not be determined.
+   *
+   * @param identifier the identifier whose source is to be returned
+   * @return the source that contains the given identifier
+   */
+  Source getSource(AstNode node) {
+    CompilationUnit unit = node.getAncestor((node) => node is CompilationUnit);
+    if (unit != null) {
+      CompilationUnitElement unitElement = unit.element;
+      if (unitElement != null) {
+        return unitElement.source;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the element with which the given name is associated, or `null` if the name is not
+   * defined within this scope.
+   *
+   * @param identifier the identifier node to lookup element for, used to report correct kind of a
+   *          problem and associate problem with
+   * @param name the name associated with the element to be returned
+   * @param referencingLibrary the library that contains the reference to the name, used to
+   *          implement library-level privacy
+   * @return the element with which the given name is associated
+   */
+  Element internalLookup(
+      Identifier identifier, String name, LibraryElement referencingLibrary);
+
+  /**
+   * Return the element with which the given name is associated, or `null` if the name is not
+   * defined within this scope. This method only returns elements that are directly defined within
+   * this scope, not elements that are defined in an enclosing scope.
+   *
+   * @param name the name associated with the element to be returned
+   * @param referencingLibrary the library that contains the reference to the name, used to
+   *          implement library-level privacy
+   * @return the element with which the given name is associated
+   */
+  Element localLookup(String name, LibraryElement referencingLibrary) {
+    if (_hasName) {
+      return _definedNames[name];
+    }
+    return null;
+  }
+
+  /**
+   * Return the element with which the given identifier is associated, or `null` if the name
+   * is not defined within this scope.
+   *
+   * @param identifier the identifier associated with the element to be returned
+   * @param referencingLibrary the library that contains the reference to the name, used to
+   *          implement library-level privacy
+   * @return the element with which the given identifier is associated
+   */
+  Element lookup(Identifier identifier, LibraryElement referencingLibrary) =>
+      internalLookup(identifier, identifier.name, referencingLibrary);
+
+  /**
+   * Return the name that will be used to look up the given element.
+   *
+   * @param element the element whose look-up name is to be returned
+   * @return the name that will be used to look up the given element
+   */
+  String _getName(Element element) {
+    if (element is MethodElement) {
+      MethodElement method = element;
+      if (method.name == "-" && method.parameters.length == 0) {
+        return UNARY_MINUS;
+      }
+    }
+    return element.name;
+  }
+
+  /**
+   * Return `true` if the given name is a library-private name.
+   *
+   * @param name the name being tested
+   * @return `true` if the given name is a library-private name
+   */
+  static bool isPrivateName(String name) =>
+      name != null && StringUtilities.startsWithChar(name, PRIVATE_NAME_PREFIX);
+}
+
+/**
+ * The abstract class `ScopedVisitor` maintains name and label scopes as an AST structure is
+ * being visited.
+ */
+abstract class ScopedVisitor extends UnifyingAstVisitor<Object> {
+  /**
+   * The element for the library containing the compilation unit being visited.
+   */
+  final LibraryElement definingLibrary;
+
+  /**
+   * The source representing the compilation unit being visited.
+   */
+  final Source source;
+
+  /**
+   * The error listener that will be informed of any errors that are found during resolution.
+   */
+  final AnalysisErrorListener errorListener;
+
+  /**
+   * The scope used to resolve identifiers.
+   */
+  Scope nameScope;
+
+  /**
+   * The object used to access the types from the core library.
+   */
+  final TypeProvider typeProvider;
+
+  /**
+   * The scope used to resolve unlabeled `break` and `continue` statements.
+   */
+  ImplicitLabelScope _implicitLabelScope = ImplicitLabelScope.ROOT;
+
+  /**
+   * The scope used to resolve labels for `break` and `continue` statements, or
+   * `null` if no labels have been defined in the current context.
+   */
+  LabelScope labelScope;
+
+  /**
+   * The class containing the AST nodes being visited,
+   * or `null` if we are not in the scope of a class.
+   */
+  ClassElement enclosingClass;
+
+  /**
+   * Initialize a newly created visitor to resolve the nodes in a compilation
+   * unit.
+   *
+   * [definingLibrary] is the element for the library containing the
+   * compilation unit being visited.
+   * [source] is the source representing the compilation unit being visited.
+   * [typeProvider] is the object used to access the types from the core
+   * library.
+   * [errorListener] is the error listener that will be informed of any errors
+   * that are found during resolution.
+   * [nameScope] is the scope used to resolve identifiers in the node that will
+   * first be visited.  If `null` or unspecified, a new [LibraryScope] will be
+   * created based on [definingLibrary] and [typeProvider].
+   */
+  ScopedVisitor(
+      this.definingLibrary, this.source, this.typeProvider, this.errorListener,
+      {Scope nameScope}) {
+    if (nameScope == null) {
+      this.nameScope = new LibraryScope(definingLibrary, errorListener);
+    } else {
+      this.nameScope = nameScope;
+    }
+  }
+
+  /**
+   * Return the implicit label scope in which the current node is being
+   * resolved.
+   */
+  ImplicitLabelScope get implicitLabelScope => _implicitLabelScope;
+
+  /**
+   * Replaces the current [Scope] with the enclosing [Scope].
+   *
+   * @return the enclosing [Scope].
+   */
+  Scope popNameScope() {
+    nameScope = nameScope.enclosingScope;
+    return nameScope;
+  }
+
+  /**
+   * Pushes a new [Scope] into the visitor.
+   *
+   * @return the new [Scope].
+   */
+  Scope pushNameScope() {
+    Scope newScope = new EnclosedScope(nameScope);
+    nameScope = newScope;
+    return nameScope;
+  }
+
+  /**
+   * Report an error with the given error code and arguments.
+   *
+   * @param errorCode the error code of the error to be reported
+   * @param node the node specifying the location of the error
+   * @param arguments the arguments to the error, used to compose the error message
+   */
+  void reportErrorForNode(ErrorCode errorCode, AstNode node,
+      [List<Object> arguments]) {
+    errorListener.onError(new AnalysisError(
+        source, node.offset, node.length, errorCode, arguments));
+  }
+
+  /**
+   * Report an error with the given error code and arguments.
+   *
+   * @param errorCode the error code of the error to be reported
+   * @param offset the offset of the location of the error
+   * @param length the length of the location of the error
+   * @param arguments the arguments to the error, used to compose the error message
+   */
+  void reportErrorForOffset(ErrorCode errorCode, int offset, int length,
+      [List<Object> arguments]) {
+    errorListener.onError(
+        new AnalysisError(source, offset, length, errorCode, arguments));
+  }
+
+  /**
+   * Report an error with the given error code and arguments.
+   *
+   * @param errorCode the error code of the error to be reported
+   * @param token the token specifying the location of the error
+   * @param arguments the arguments to the error, used to compose the error message
+   */
+  void reportErrorForToken(ErrorCode errorCode, sc.Token token,
+      [List<Object> arguments]) {
+    errorListener.onError(new AnalysisError(
+        source, token.offset, token.length, errorCode, arguments));
+  }
+
+  /**
+   * Visit the given AST node if it is not null.
+   *
+   * @param node the node to be visited
+   */
+  void safelyVisit(AstNode node) {
+    if (node != null) {
+      node.accept(this);
+    }
+  }
+
+  @override
+  Object visitBlock(Block node) {
+    Scope outerScope = nameScope;
+    try {
+      EnclosedScope enclosedScope = new EnclosedScope(nameScope);
+      _hideNamesDefinedInBlock(enclosedScope, node);
+      nameScope = enclosedScope;
+      super.visitBlock(node);
+    } finally {
+      nameScope = outerScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitBlockFunctionBody(BlockFunctionBody node) {
+    ImplicitLabelScope implicitOuterScope = _implicitLabelScope;
+    try {
+      _implicitLabelScope = ImplicitLabelScope.ROOT;
+      super.visitBlockFunctionBody(node);
+    } finally {
+      _implicitLabelScope = implicitOuterScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitCatchClause(CatchClause node) {
+    SimpleIdentifier exception = node.exceptionParameter;
+    if (exception != null) {
+      Scope outerScope = nameScope;
+      try {
+        nameScope = new EnclosedScope(nameScope);
+        nameScope.define(exception.staticElement);
+        SimpleIdentifier stackTrace = node.stackTraceParameter;
+        if (stackTrace != null) {
+          nameScope.define(stackTrace.staticElement);
+        }
+        super.visitCatchClause(node);
+      } finally {
+        nameScope = outerScope;
+      }
+    } else {
+      super.visitCatchClause(node);
+    }
+    return null;
+  }
+
+  @override
+  Object visitClassDeclaration(ClassDeclaration node) {
+    ClassElement classElement = node.element;
+    Scope outerScope = nameScope;
+    try {
+      if (classElement == null) {
+        AnalysisEngine.instance.logger.logInformation(
+            "Missing element for class declaration ${node.name.name} in ${definingLibrary.source.fullName}",
+            new CaughtException(new AnalysisException(), null));
+        super.visitClassDeclaration(node);
+      } else {
+        ClassElement outerClass = enclosingClass;
+        try {
+          enclosingClass = node.element;
+          nameScope = new TypeParameterScope(nameScope, classElement);
+          visitClassDeclarationInScope(node);
+          nameScope = new ClassScope(nameScope, classElement);
+          visitClassMembersInScope(node);
+        } finally {
+          enclosingClass = outerClass;
+        }
+      }
+    } finally {
+      nameScope = outerScope;
+    }
+    return null;
+  }
+
+  void visitClassDeclarationInScope(ClassDeclaration node) {
+    safelyVisit(node.name);
+    safelyVisit(node.typeParameters);
+    safelyVisit(node.extendsClause);
+    safelyVisit(node.withClause);
+    safelyVisit(node.implementsClause);
+    safelyVisit(node.nativeClause);
+  }
+
+  void visitClassMembersInScope(ClassDeclaration node) {
+    safelyVisit(node.documentationComment);
+    node.metadata.accept(this);
+    node.members.accept(this);
+  }
+
+  @override
+  Object visitClassTypeAlias(ClassTypeAlias node) {
+    Scope outerScope = nameScope;
+    try {
+      ClassElement element = node.element;
+      nameScope =
+          new ClassScope(new TypeParameterScope(nameScope, element), element);
+      super.visitClassTypeAlias(node);
+    } finally {
+      nameScope = outerScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    ConstructorElement constructorElement = node.element;
+    Scope outerScope = nameScope;
+    try {
+      if (constructorElement == null) {
+        StringBuffer buffer = new StringBuffer();
+        buffer.write("Missing element for constructor ");
+        buffer.write(node.returnType.name);
+        if (node.name != null) {
+          buffer.write(".");
+          buffer.write(node.name.name);
+        }
+        buffer.write(" in ");
+        buffer.write(definingLibrary.source.fullName);
+        AnalysisEngine.instance.logger.logInformation(buffer.toString(),
+            new CaughtException(new AnalysisException(), null));
+      } else {
+        nameScope = new FunctionScope(nameScope, constructorElement);
+      }
+      super.visitConstructorDeclaration(node);
+    } finally {
+      nameScope = outerScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitDeclaredIdentifier(DeclaredIdentifier node) {
+    VariableElement element = node.element;
+    if (element != null) {
+      nameScope.define(element);
+    }
+    super.visitDeclaredIdentifier(node);
+    return null;
+  }
+
+  @override
+  Object visitDoStatement(DoStatement node) {
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
+    try {
+      _implicitLabelScope = _implicitLabelScope.nest(node);
+      visitStatementInScope(node.body);
+      safelyVisit(node.condition);
+    } finally {
+      _implicitLabelScope = outerImplicitScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitEnumDeclaration(EnumDeclaration node) {
+    ClassElement classElement = node.element;
+    Scope outerScope = nameScope;
+    try {
+      if (classElement == null) {
+        AnalysisEngine.instance.logger.logInformation(
+            "Missing element for enum declaration ${node.name.name} in ${definingLibrary.source.fullName}",
+            new CaughtException(new AnalysisException(), null));
+        super.visitEnumDeclaration(node);
+      } else {
+        ClassElement outerClass = enclosingClass;
+        try {
+          enclosingClass = node.element;
+          nameScope = new ClassScope(nameScope, classElement);
+          visitEnumMembersInScope(node);
+        } finally {
+          enclosingClass = outerClass;
+        }
+      }
+    } finally {
+      nameScope = outerScope;
+    }
+    return null;
+  }
+
+  void visitEnumMembersInScope(EnumDeclaration node) {
+    safelyVisit(node.documentationComment);
+    node.metadata.accept(this);
+    node.constants.accept(this);
+  }
+
+  @override
+  Object visitForEachStatement(ForEachStatement node) {
+    Scope outerNameScope = nameScope;
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
+    try {
+      nameScope = new EnclosedScope(nameScope);
+      _implicitLabelScope = _implicitLabelScope.nest(node);
+      visitForEachStatementInScope(node);
+    } finally {
+      nameScope = outerNameScope;
+      _implicitLabelScope = outerImplicitScope;
+    }
+    return null;
+  }
+
+  /**
+   * Visit the given statement after it's scope has been created. This replaces the normal call to
+   * the inherited visit method so that ResolverVisitor can intervene when type propagation is
+   * enabled.
+   *
+   * @param node the statement to be visited
+   */
+  void visitForEachStatementInScope(ForEachStatement node) {
+    //
+    // We visit the iterator before the loop variable because the loop variable
+    // cannot be in scope while visiting the iterator.
+    //
+    safelyVisit(node.identifier);
+    safelyVisit(node.iterable);
+    safelyVisit(node.loopVariable);
+    visitStatementInScope(node.body);
+  }
+
+  @override
+  Object visitFormalParameterList(FormalParameterList node) {
+    super.visitFormalParameterList(node);
+    // We finished resolving function signature, now include formal parameters
+    // scope.  Note: we must not do this if the parent is a
+    // FunctionTypedFormalParameter, because in that case we aren't finished
+    // resolving the full function signature, just a part of it.
+    if (nameScope is FunctionScope &&
+        node.parent is! FunctionTypedFormalParameter) {
+      (nameScope as FunctionScope).defineParameters();
+    }
+    if (nameScope is FunctionTypeScope) {
+      (nameScope as FunctionTypeScope).defineParameters();
+    }
+    return null;
+  }
+
+  @override
+  Object visitForStatement(ForStatement node) {
+    Scope outerNameScope = nameScope;
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
+    try {
+      nameScope = new EnclosedScope(nameScope);
+      _implicitLabelScope = _implicitLabelScope.nest(node);
+      visitForStatementInScope(node);
+    } finally {
+      nameScope = outerNameScope;
+      _implicitLabelScope = outerImplicitScope;
+    }
+    return null;
+  }
+
+  /**
+   * Visit the given statement after it's scope has been created. This replaces the normal call to
+   * the inherited visit method so that ResolverVisitor can intervene when type propagation is
+   * enabled.
+   *
+   * @param node the statement to be visited
+   */
+  void visitForStatementInScope(ForStatement node) {
+    safelyVisit(node.variables);
+    safelyVisit(node.initialization);
+    safelyVisit(node.condition);
+    node.updaters.accept(this);
+    visitStatementInScope(node.body);
+  }
+
+  @override
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    ExecutableElement functionElement = node.element;
+    if (functionElement != null &&
+        functionElement.enclosingElement is! CompilationUnitElement) {
+      nameScope.define(functionElement);
+    }
+    Scope outerScope = nameScope;
+    try {
+      if (functionElement == null) {
+        AnalysisEngine.instance.logger.logInformation(
+            "Missing element for top-level function ${node.name.name} in ${definingLibrary.source.fullName}",
+            new CaughtException(new AnalysisException(), null));
+      } else {
+        nameScope = new FunctionScope(nameScope, functionElement);
+      }
+      super.visitFunctionDeclaration(node);
+    } finally {
+      nameScope = outerScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitFunctionExpression(FunctionExpression node) {
+    if (node.parent is FunctionDeclaration) {
+      // We have already created a function scope and don't need to do so again.
+      super.visitFunctionExpression(node);
+    } else {
+      Scope outerScope = nameScope;
+      try {
+        ExecutableElement functionElement = node.element;
+        if (functionElement == null) {
+          StringBuffer buffer = new StringBuffer();
+          buffer.write("Missing element for function ");
+          AstNode parent = node.parent;
+          while (parent != null) {
+            if (parent is Declaration) {
+              Element parentElement = parent.element;
+              buffer.write(parentElement == null
+                  ? "<unknown> "
+                  : "${parentElement.name} ");
+            }
+            parent = parent.parent;
+          }
+          buffer.write("in ");
+          buffer.write(definingLibrary.source.fullName);
+          AnalysisEngine.instance.logger.logInformation(buffer.toString(),
+              new CaughtException(new AnalysisException(), null));
+        } else {
+          nameScope = new FunctionScope(nameScope, functionElement);
+        }
+        super.visitFunctionExpression(node);
+      } finally {
+        nameScope = outerScope;
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+    Scope outerScope = nameScope;
+    try {
+      nameScope = new FunctionTypeScope(nameScope, node.element);
+      super.visitFunctionTypeAlias(node);
+    } finally {
+      nameScope = outerScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
+    Scope outerScope = nameScope;
+    try {
+      ParameterElement parameterElement = node.element;
+      if (parameterElement == null) {
+        AnalysisEngine.instance.logger.logInformation(
+            "Missing element for function typed formal parameter ${node.identifier.name} in ${definingLibrary.source.fullName}",
+            new CaughtException(new AnalysisException(), null));
+      } else {
+        nameScope = new EnclosedScope(nameScope);
+        for (TypeParameterElement typeParameter
+            in parameterElement.typeParameters) {
+          nameScope.define(typeParameter);
+        }
+      }
+      super.visitFunctionTypedFormalParameter(node);
+    } finally {
+      nameScope = outerScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitIfStatement(IfStatement node) {
+    safelyVisit(node.condition);
+    visitStatementInScope(node.thenStatement);
+    visitStatementInScope(node.elseStatement);
+    return null;
+  }
+
+  @override
+  Object visitLabeledStatement(LabeledStatement node) {
+    LabelScope outerScope = _addScopesFor(node.labels, node.unlabeled);
+    try {
+      super.visitLabeledStatement(node);
+    } finally {
+      labelScope = outerScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    Scope outerScope = nameScope;
+    try {
+      ExecutableElement methodElement = node.element;
+      if (methodElement == null) {
+        AnalysisEngine.instance.logger.logInformation(
+            "Missing element for method ${node.name.name} in ${definingLibrary.source.fullName}",
+            new CaughtException(new AnalysisException(), null));
+      } else {
+        nameScope = new FunctionScope(nameScope, methodElement);
+      }
+      super.visitMethodDeclaration(node);
+    } finally {
+      nameScope = outerScope;
+    }
+    return null;
+  }
+
+  /**
+   * Visit the given statement after it's scope has been created. This is used by ResolverVisitor to
+   * correctly visit the 'then' and 'else' statements of an 'if' statement.
+   *
+   * @param node the statement to be visited
+   */
+  void visitStatementInScope(Statement node) {
+    if (node is Block) {
+      // Don't create a scope around a block because the block will create it's
+      // own scope.
+      visitBlock(node);
+    } else if (node != null) {
+      Scope outerNameScope = nameScope;
+      try {
+        nameScope = new EnclosedScope(nameScope);
+        node.accept(this);
+      } finally {
+        nameScope = outerNameScope;
+      }
+    }
+  }
+
+  @override
+  Object visitSwitchCase(SwitchCase node) {
+    node.expression.accept(this);
+    Scope outerNameScope = nameScope;
+    try {
+      nameScope = new EnclosedScope(nameScope);
+      node.statements.accept(this);
+    } finally {
+      nameScope = outerNameScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitSwitchDefault(SwitchDefault node) {
+    Scope outerNameScope = nameScope;
+    try {
+      nameScope = new EnclosedScope(nameScope);
+      node.statements.accept(this);
+    } finally {
+      nameScope = outerNameScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitSwitchStatement(SwitchStatement node) {
+    LabelScope outerScope = labelScope;
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
+    try {
+      _implicitLabelScope = _implicitLabelScope.nest(node);
+      for (SwitchMember member in node.members) {
+        for (Label label in member.labels) {
+          SimpleIdentifier labelName = label.label;
+          LabelElement labelElement = labelName.staticElement as LabelElement;
+          labelScope =
+              new LabelScope(labelScope, labelName.name, member, labelElement);
+        }
+      }
+      super.visitSwitchStatement(node);
+    } finally {
+      labelScope = outerScope;
+      _implicitLabelScope = outerImplicitScope;
+    }
+    return null;
+  }
+
+  @override
+  Object visitVariableDeclaration(VariableDeclaration node) {
+    super.visitVariableDeclaration(node);
+    if (node.parent.parent is! TopLevelVariableDeclaration &&
+        node.parent.parent is! FieldDeclaration) {
+      VariableElement element = node.element;
+      if (element != null) {
+        nameScope.define(element);
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitWhileStatement(WhileStatement node) {
+    safelyVisit(node.condition);
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
+    try {
+      _implicitLabelScope = _implicitLabelScope.nest(node);
+      visitStatementInScope(node.body);
+    } finally {
+      _implicitLabelScope = outerImplicitScope;
+    }
+    return null;
+  }
+
+  /**
+   * Add scopes for each of the given labels.
+   *
+   * @param labels the labels for which new scopes are to be added
+   * @return the scope that was in effect before the new scopes were added
+   */
+  LabelScope _addScopesFor(NodeList<Label> labels, AstNode node) {
+    LabelScope outerScope = labelScope;
+    for (Label label in labels) {
+      SimpleIdentifier labelNameNode = label.label;
+      String labelName = labelNameNode.name;
+      LabelElement labelElement = labelNameNode.staticElement as LabelElement;
+      labelScope = new LabelScope(labelScope, labelName, node, labelElement);
+    }
+    return outerScope;
+  }
+
+  /**
+   * Marks the local declarations of the given [Block] hidden in the enclosing scope.
+   * According to the scoping rules name is hidden if block defines it, but name is defined after
+   * its declaration statement.
+   */
+  void _hideNamesDefinedInBlock(EnclosedScope scope, Block block) {
+    NodeList<Statement> statements = block.statements;
+    int statementCount = statements.length;
+    for (int i = 0; i < statementCount; i++) {
+      Statement statement = statements[i];
+      if (statement is VariableDeclarationStatement) {
+        VariableDeclarationStatement vds = statement;
+        NodeList<VariableDeclaration> variables = vds.variables.variables;
+        int variableCount = variables.length;
+        for (int j = 0; j < variableCount; j++) {
+          scope.hide(variables[j].element);
+        }
+      } else if (statement is FunctionDeclarationStatement) {
+        FunctionDeclarationStatement fds = statement;
+        scope.hide(fds.functionDeclaration.element);
+      }
+    }
+  }
+}
+
+/**
+ * Instances of this class manage the knowledge of what the set of subtypes are for a given type.
+ */
+class SubtypeManager {
+  /**
+   * A map between [ClassElement]s and a set of [ClassElement]s that are subtypes of the
+   * key.
+   */
+  HashMap<ClassElement, HashSet<ClassElement>> _subtypeMap =
+      new HashMap<ClassElement, HashSet<ClassElement>>();
+
+  /**
+   * The set of all [LibraryElement]s that have been visited by the manager. This is used both
+   * to prevent infinite loops in the recursive methods, and also as a marker for the scope of the
+   * libraries visited by this manager.
+   */
+  HashSet<LibraryElement> _visitedLibraries = new HashSet<LibraryElement>();
+
+  /**
+   * Given some [ClassElement], return the set of all subtypes, and subtypes of subtypes.
+   *
+   * @param classElement the class to recursively return the set of subtypes of
+   */
+  HashSet<ClassElement> computeAllSubtypes(ClassElement classElement) {
+    // Ensure that we have generated the subtype map for the library
+    _computeSubtypesInLibrary(classElement.library);
+    // use the subtypeMap to compute the set of all subtypes and subtype's
+    // subtypes
+    HashSet<ClassElement> allSubtypes = new HashSet<ClassElement>();
+    _safelyComputeAllSubtypes(
+        classElement, new HashSet<ClassElement>(), allSubtypes);
+    return allSubtypes;
+  }
+
+  /**
+   * Given some [LibraryElement], visit all of the types in the library, the passed library,
+   * and any imported libraries, will be in the [visitedLibraries] set.
+   *
+   * @param libraryElement the library to visit, it it hasn't been visited already
+   */
+  void ensureLibraryVisited(LibraryElement libraryElement) {
+    _computeSubtypesInLibrary(libraryElement);
+  }
+
+  /**
+   * Given some [ClassElement], this method adds all of the pairs combinations of itself and
+   * all of its supertypes to the [subtypeMap] map.
+   *
+   * @param classElement the class element
+   */
+  void _computeSubtypesInClass(ClassElement classElement) {
+    InterfaceType supertypeType = classElement.supertype;
+    if (supertypeType != null) {
+      ClassElement supertypeElement = supertypeType.element;
+      if (supertypeElement != null) {
+        _putInSubtypeMap(supertypeElement, classElement);
+      }
+    }
+    List<InterfaceType> interfaceTypes = classElement.interfaces;
+    for (InterfaceType interfaceType in interfaceTypes) {
+      ClassElement interfaceElement = interfaceType.element;
+      if (interfaceElement != null) {
+        _putInSubtypeMap(interfaceElement, classElement);
+      }
+    }
+    List<InterfaceType> mixinTypes = classElement.mixins;
+    for (InterfaceType mixinType in mixinTypes) {
+      ClassElement mixinElement = mixinType.element;
+      if (mixinElement != null) {
+        _putInSubtypeMap(mixinElement, classElement);
+      }
+    }
+  }
+
+  /**
+   * Given some [CompilationUnitElement], this method calls
+   * [computeAllSubtypes] on all of the [ClassElement]s in the
+   * compilation unit.
+   *
+   * @param unitElement the compilation unit element
+   */
+  void _computeSubtypesInCompilationUnit(CompilationUnitElement unitElement) {
+    List<ClassElement> classElements = unitElement.types;
+    for (ClassElement classElement in classElements) {
+      _computeSubtypesInClass(classElement);
+    }
+  }
+
+  /**
+   * Given some [LibraryElement], this method calls
+   * [computeAllSubtypes] on all of the [ClassElement]s in the
+   * compilation unit, and itself for all imported and exported libraries. All visited libraries are
+   * added to the [visitedLibraries] set.
+   *
+   * @param libraryElement the library element
+   */
+  void _computeSubtypesInLibrary(LibraryElement libraryElement) {
+    if (libraryElement == null || _visitedLibraries.contains(libraryElement)) {
+      return;
+    }
+    _visitedLibraries.add(libraryElement);
+    _computeSubtypesInCompilationUnit(libraryElement.definingCompilationUnit);
+    List<CompilationUnitElement> parts = libraryElement.parts;
+    for (CompilationUnitElement part in parts) {
+      _computeSubtypesInCompilationUnit(part);
+    }
+    List<LibraryElement> imports = libraryElement.importedLibraries;
+    for (LibraryElement importElt in imports) {
+      _computeSubtypesInLibrary(importElt.library);
+    }
+    List<LibraryElement> exports = libraryElement.exportedLibraries;
+    for (LibraryElement exportElt in exports) {
+      _computeSubtypesInLibrary(exportElt.library);
+    }
+  }
+
+  /**
+   * Add some key/ value pair into the [subtypeMap] map.
+   *
+   * @param supertypeElement the key for the [subtypeMap] map
+   * @param subtypeElement the value for the [subtypeMap] map
+   */
+  void _putInSubtypeMap(
+      ClassElement supertypeElement, ClassElement subtypeElement) {
+    HashSet<ClassElement> subtypes = _subtypeMap[supertypeElement];
+    if (subtypes == null) {
+      subtypes = new HashSet<ClassElement>();
+      _subtypeMap[supertypeElement] = subtypes;
+    }
+    subtypes.add(subtypeElement);
+  }
+
+  /**
+   * Given some [ClassElement] and a [HashSet<ClassElement>], this method recursively
+   * adds all of the subtypes of the [ClassElement] to the passed array.
+   *
+   * @param classElement the type to compute the set of subtypes of
+   * @param visitedClasses the set of class elements that this method has already recursively seen
+   * @param allSubtypes the computed set of subtypes of the passed class element
+   */
+  void _safelyComputeAllSubtypes(ClassElement classElement,
+      HashSet<ClassElement> visitedClasses, HashSet<ClassElement> allSubtypes) {
+    if (!visitedClasses.add(classElement)) {
+      // if this class has already been called on this class element
+      return;
+    }
+    HashSet<ClassElement> subtypes = _subtypeMap[classElement];
+    if (subtypes == null) {
+      return;
+    }
+    for (ClassElement subtype in subtypes) {
+      _safelyComputeAllSubtypes(subtype, visitedClasses, allSubtypes);
+    }
+    allSubtypes.addAll(subtypes);
+  }
+}
+
+/**
+ * Instances of the class `ToDoFinder` find to-do comments in Dart code.
+ */
+class ToDoFinder {
+  /**
+   * The error reporter by which to-do comments will be reported.
+   */
+  final ErrorReporter _errorReporter;
+
+  /**
+   * Initialize a newly created to-do finder to report to-do comments to the given reporter.
+   *
+   * @param errorReporter the error reporter by which to-do comments will be reported
+   */
+  ToDoFinder(this._errorReporter);
+
+  /**
+   * Search the comments in the given compilation unit for to-do comments and report an error for
+   * each.
+   *
+   * @param unit the compilation unit containing the to-do comments
+   */
+  void findIn(CompilationUnit unit) {
+    _gatherTodoComments(unit.beginToken);
+  }
+
+  /**
+   * Search the comment tokens reachable from the given token and create errors for each to-do
+   * comment.
+   *
+   * @param token the head of the list of tokens being searched
+   */
+  void _gatherTodoComments(sc.Token token) {
+    while (token != null && token.type != sc.TokenType.EOF) {
+      sc.Token commentToken = token.precedingComments;
+      while (commentToken != null) {
+        if (commentToken.type == sc.TokenType.SINGLE_LINE_COMMENT ||
+            commentToken.type == sc.TokenType.MULTI_LINE_COMMENT) {
+          _scrapeTodoComment(commentToken);
+        }
+        commentToken = commentToken.next;
+      }
+      token = token.next;
+    }
+  }
+
+  /**
+   * Look for user defined tasks in comments and convert them into info level analysis issues.
+   *
+   * @param commentToken the comment token to analyze
+   */
+  void _scrapeTodoComment(sc.Token commentToken) {
+    JavaPatternMatcher matcher =
+        new JavaPatternMatcher(TodoCode.TODO_REGEX, commentToken.lexeme);
+    if (matcher.find()) {
+      int offset =
+          commentToken.offset + matcher.start() + matcher.group(1).length;
+      int length = matcher.group(2).length;
+      _errorReporter.reportErrorForOffset(
+          TodoCode.TODO, offset, length, [matcher.group(2)]);
+    }
+  }
+}
+
+/**
+ * Instances of the class `TypeOverrideManager` manage the ability to override the type of an
+ * element within a given context.
+ */
+class TypeOverrideManager {
+  /**
+   * The current override scope, or `null` if no scope has been entered.
+   */
+  TypeOverrideManager_TypeOverrideScope currentScope;
+
+  /**
+   * Apply a set of overrides that were previously captured.
+   *
+   * @param overrides the overrides to be applied
+   */
+  void applyOverrides(Map<VariableElement, DartType> overrides) {
+    if (currentScope == null) {
+      throw new IllegalStateException("Cannot apply overrides without a scope");
+    }
+    currentScope.applyOverrides(overrides);
+  }
+
+  /**
+   * Return a table mapping the elements whose type is overridden in the current scope to the
+   * overriding type.
+   *
+   * @return the overrides in the current scope
+   */
+  Map<VariableElement, DartType> captureLocalOverrides() {
+    if (currentScope == null) {
+      throw new IllegalStateException(
+          "Cannot capture local overrides without a scope");
+    }
+    return currentScope.captureLocalOverrides();
+  }
+
+  /**
+   * Return a map from the elements for the variables in the given list that have their types
+   * overridden to the overriding type.
+   *
+   * @param variableList the list of variables whose overriding types are to be captured
+   * @return a table mapping elements to their overriding types
+   */
+  Map<VariableElement, DartType> captureOverrides(
+      VariableDeclarationList variableList) {
+    if (currentScope == null) {
+      throw new IllegalStateException(
+          "Cannot capture overrides without a scope");
+    }
+    return currentScope.captureOverrides(variableList);
+  }
+
+  /**
+   * Enter a new override scope.
+   */
+  void enterScope() {
+    currentScope = new TypeOverrideManager_TypeOverrideScope(currentScope);
+  }
+
+  /**
+   * Exit the current override scope.
+   */
+  void exitScope() {
+    if (currentScope == null) {
+      throw new IllegalStateException("No scope to exit");
+    }
+    currentScope = currentScope._outerScope;
+  }
+
+  /**
+   * Return the best type information available for the given element. If the type of the element
+   * has been overridden, then return the overriding type. Otherwise, return the static type.
+   *
+   * @param element the element for which type information is to be returned
+   * @return the best type information available for the given element
+   */
+  DartType getBestType(VariableElement element) {
+    DartType bestType = getType(element);
+    return bestType == null ? element.type : bestType;
+  }
+
+  /**
+   * Return the overridden type of the given element, or `null` if the type of the element has
+   * not been overridden.
+   *
+   * @param element the element whose type might have been overridden
+   * @return the overridden type of the given element
+   */
+  DartType getType(Element element) {
+    if (currentScope == null) {
+      return null;
+    }
+    return currentScope.getType(element);
+  }
+
+  /**
+   * Update overrides assuming [perBranchOverrides] is the collection of
+   * per-branch overrides for *all* branches flowing into a join point.
+   *
+   * If a variable type in any of branches is not the same as its type before
+   * the branching, then its propagated type is reset to `null`.
+   */
+  void mergeOverrides(List<Map<VariableElement, DartType>> perBranchOverrides) {
+    for (Map<VariableElement, DartType> branch in perBranchOverrides) {
+      branch.forEach((VariableElement variable, DartType branchType) {
+        DartType currentType = currentScope.getType(variable);
+        if (currentType != branchType) {
+          currentScope.resetType(variable);
+        }
+      });
+    }
+  }
+
+  /**
+   * Set the overridden type of the given element to the given type
+   *
+   * @param element the element whose type might have been overridden
+   * @param type the overridden type of the given element
+   */
+  void setType(VariableElement element, DartType type) {
+    if (currentScope == null) {
+      throw new IllegalStateException("Cannot override without a scope");
+    }
+    currentScope.setType(element, type);
+  }
+}
+
+/**
+ * Instances of the class `TypeOverrideScope` represent a scope in which the types of
+ * elements can be overridden.
+ */
+class TypeOverrideManager_TypeOverrideScope {
+  /**
+   * The outer scope in which types might be overridden.
+   */
+  final TypeOverrideManager_TypeOverrideScope _outerScope;
+
+  /**
+   * A table mapping elements to the overridden type of that element.
+   */
+  Map<VariableElement, DartType> _overridenTypes =
+      new HashMap<VariableElement, DartType>();
+
+  /**
+   * Initialize a newly created scope to be an empty child of the given scope.
+   *
+   * @param outerScope the outer scope in which types might be overridden
+   */
+  TypeOverrideManager_TypeOverrideScope(this._outerScope);
+
+  /**
+   * Apply a set of overrides that were previously captured.
+   *
+   * @param overrides the overrides to be applied
+   */
+  void applyOverrides(Map<VariableElement, DartType> overrides) {
+    _overridenTypes.addAll(overrides);
+  }
+
+  /**
+   * Return a table mapping the elements whose type is overridden in the current scope to the
+   * overriding type.
+   *
+   * @return the overrides in the current scope
+   */
+  Map<VariableElement, DartType> captureLocalOverrides() => _overridenTypes;
+
+  /**
+   * Return a map from the elements for the variables in the given list that have their types
+   * overridden to the overriding type.
+   *
+   * @param variableList the list of variables whose overriding types are to be captured
+   * @return a table mapping elements to their overriding types
+   */
+  Map<VariableElement, DartType> captureOverrides(
+      VariableDeclarationList variableList) {
+    Map<VariableElement, DartType> overrides =
+        new HashMap<VariableElement, DartType>();
+    if (variableList.isConst || variableList.isFinal) {
+      for (VariableDeclaration variable in variableList.variables) {
+        VariableElement element = variable.element;
+        if (element != null) {
+          DartType type = _overridenTypes[element];
+          if (type != null) {
+            overrides[element] = type;
+          }
+        }
+      }
+    }
+    return overrides;
+  }
+
+  /**
+   * Return the overridden type of the given element, or `null` if the type of the element
+   * has not been overridden.
+   *
+   * @param element the element whose type might have been overridden
+   * @return the overridden type of the given element
+   */
+  DartType getType(Element element) {
+    if (element is PropertyAccessorElement) {
+      element = (element as PropertyAccessorElement).variable;
+    }
+    DartType type = _overridenTypes[element];
+    if (_overridenTypes.containsKey(element)) {
+      return type;
+    }
+    if (type != null) {
+      return type;
+    } else if (_outerScope != null) {
+      return _outerScope.getType(element);
+    }
+    return null;
+  }
+
+  /**
+   * Clears the overridden type of the given [element].
+   */
+  void resetType(VariableElement element) {
+    _overridenTypes[element] = null;
+  }
+
+  /**
+   * Set the overridden type of the given element to the given type
+   *
+   * @param element the element whose type might have been overridden
+   * @param type the overridden type of the given element
+   */
+  void setType(VariableElement element, DartType type) {
+    _overridenTypes[element] = type;
+  }
+}
+
+/**
+ * Instances of the class `TypeParameterScope` implement the scope defined by the type
+ * parameters in a class.
+ */
+class TypeParameterScope extends EnclosedScope {
+  /**
+   * Initialize a newly created scope enclosed within another scope.
+   *
+   * @param enclosingScope the scope in which this scope is lexically enclosed
+   * @param typeElement the element representing the type represented by this scope
+   */
+  TypeParameterScope(Scope enclosingScope, ClassElement typeElement)
+      : super(enclosingScope) {
+    if (typeElement == null) {
+      throw new IllegalArgumentException("class element cannot be null");
+    }
+    _defineTypeParameters(typeElement);
+  }
+
+  /**
+   * Define the type parameters for the class.
+   *
+   * @param typeElement the element representing the type represented by this scope
+   */
+  void _defineTypeParameters(ClassElement typeElement) {
+    for (TypeParameterElement typeParameter in typeElement.typeParameters) {
+      define(typeParameter);
+    }
+  }
+}
+
+/**
+ * Instances of the class `TypePromotionManager` manage the ability to promote types of local
+ * variables and formal parameters from their declared types based on control flow.
+ */
+class TypePromotionManager {
+  /**
+   * The current promotion scope, or `null` if no scope has been entered.
+   */
+  TypePromotionManager_TypePromoteScope currentScope;
+
+  /**
+   * Returns the elements with promoted types.
+   */
+  Iterable<Element> get promotedElements => currentScope.promotedElements;
+
+  /**
+   * Enter a new promotions scope.
+   */
+  void enterScope() {
+    currentScope = new TypePromotionManager_TypePromoteScope(currentScope);
+  }
+
+  /**
+   * Exit the current promotion scope.
+   */
+  void exitScope() {
+    if (currentScope == null) {
+      throw new IllegalStateException("No scope to exit");
+    }
+    currentScope = currentScope._outerScope;
+  }
+
+  /**
+   * Returns static type of the given variable - declared or promoted.
+   *
+   * @return the static type of the given variable - declared or promoted
+   */
+  DartType getStaticType(VariableElement variable) {
+    DartType staticType = getType(variable);
+    if (staticType == null) {
+      staticType = variable.type;
+    }
+    return staticType;
+  }
+
+  /**
+   * Return the promoted type of the given element, or `null` if the type of the element has
+   * not been promoted.
+   *
+   * @param element the element whose type might have been promoted
+   * @return the promoted type of the given element
+   */
+  DartType getType(Element element) {
+    if (currentScope == null) {
+      return null;
+    }
+    return currentScope.getType(element);
+  }
+
+  /**
+   * Set the promoted type of the given element to the given type.
+   *
+   * @param element the element whose type might have been promoted
+   * @param type the promoted type of the given element
+   */
+  void setType(Element element, DartType type) {
+    if (currentScope == null) {
+      throw new IllegalStateException("Cannot promote without a scope");
+    }
+    currentScope.setType(element, type);
+  }
+}
+
+/**
+ * Instances of the class `TypePromoteScope` represent a scope in which the types of
+ * elements can be promoted.
+ */
+class TypePromotionManager_TypePromoteScope {
+  /**
+   * The outer scope in which types might be promoter.
+   */
+  final TypePromotionManager_TypePromoteScope _outerScope;
+
+  /**
+   * A table mapping elements to the promoted type of that element.
+   */
+  HashMap<Element, DartType> _promotedTypes = new HashMap<Element, DartType>();
+
+  /**
+   * Initialize a newly created scope to be an empty child of the given scope.
+   *
+   * @param outerScope the outer scope in which types might be promoted
+   */
+  TypePromotionManager_TypePromoteScope(this._outerScope);
+
+  /**
+   * Returns the elements with promoted types.
+   */
+  Iterable<Element> get promotedElements => _promotedTypes.keys.toSet();
+
+  /**
+   * Return the promoted type of the given element, or `null` if the type of the element has
+   * not been promoted.
+   *
+   * @param element the element whose type might have been promoted
+   * @return the promoted type of the given element
+   */
+  DartType getType(Element element) {
+    DartType type = _promotedTypes[element];
+    if (type == null && element is PropertyAccessorElement) {
+      type = _promotedTypes[element.variable];
+    }
+    if (type != null) {
+      return type;
+    } else if (_outerScope != null) {
+      return _outerScope.getType(element);
+    }
+    return null;
+  }
+
+  /**
+   * Set the promoted type of the given element to the given type.
+   *
+   * @param element the element whose type might have been promoted
+   * @param type the promoted type of the given element
+   */
+  void setType(Element element, DartType type) {
+    _promotedTypes[element] = type;
+  }
+}
+
+/**
+ * The interface `TypeProvider` defines the behavior of objects that provide access to types
+ * defined by the language.
+ */
+abstract class TypeProvider {
+  /**
+   * Return the type representing the built-in type 'bool'.
+   */
+  InterfaceType get boolType;
+
+  /**
+   * Return the type representing the type 'bottom'.
+   */
+  DartType get bottomType;
+
+  /**
+   * Return the type representing the built-in type 'Deprecated'.
+   */
+  InterfaceType get deprecatedType;
+
+  /**
+   * Return the type representing the built-in type 'double'.
+   */
+  InterfaceType get doubleType;
+
+  /**
+   * Return the type representing the built-in type 'dynamic'.
+   */
+  DartType get dynamicType;
+
+  /**
+   * Return the type representing the built-in type 'Function'.
+   */
+  InterfaceType get functionType;
+
+  /**
+   * Return the type representing 'Future<dynamic>'.
+   */
+  InterfaceType get futureDynamicType;
+
+  /**
+   * Return the type representing 'Future<Null>'.
+   */
+  InterfaceType get futureNullType;
+
+  /**
+   * Return the type representing the built-in type 'Future'.
+   */
+  InterfaceType get futureType;
+
+  /**
+   * Return the type representing the built-in type 'int'.
+   */
+  InterfaceType get intType;
+
+  /**
+   * Return the type representing the type 'Iterable<dynamic>'.
+   */
+  InterfaceType get iterableDynamicType;
+
+  /**
+   * Return the type representing the built-in type 'Iterable'.
+   */
+  InterfaceType get iterableType;
+
+  /**
+   * Return the type representing the built-in type 'List'.
+   */
+  InterfaceType get listType;
+
+  /**
+   * Return the type representing the built-in type 'Map'.
+   */
+  InterfaceType get mapType;
+
+  /**
+   * Return a list containing all of the types that cannot be either extended or
+   * implemented.
+   */
+  List<InterfaceType> get nonSubtypableTypes;
+
+  /**
+   * Return a [DartObjectImpl] representing the `null` object.
+   */
+  DartObjectImpl get nullObject;
+
+  /**
+   * Return the type representing the built-in type 'Null'.
+   */
+  InterfaceType get nullType;
+
+  /**
+   * Return the type representing the built-in type 'num'.
+   */
+  InterfaceType get numType;
+
+  /**
+   * Return the type representing the built-in type 'Object'.
+   */
+  InterfaceType get objectType;
+
+  /**
+   * Return the type representing the built-in type 'StackTrace'.
+   */
+  InterfaceType get stackTraceType;
+
+  /**
+   * Return the type representing 'Stream<dynamic>'.
+   */
+  InterfaceType get streamDynamicType;
+
+  /**
+   * Return the type representing the built-in type 'Stream'.
+   */
+  InterfaceType get streamType;
+
+  /**
+   * Return the type representing the built-in type 'String'.
+   */
+  InterfaceType get stringType;
+
+  /**
+   * Return the type representing the built-in type 'Symbol'.
+   */
+  InterfaceType get symbolType;
+
+  /**
+   * Return the type representing the built-in type 'Type'.
+   */
+  InterfaceType get typeType;
+
+  /**
+   * Return the type representing typenames that can't be resolved.
+   */
+  DartType get undefinedType;
+}
+
+/**
+ * Instances of the class `TypeProviderImpl` provide access to types defined by the language
+ * by looking for those types in the element model for the core library.
+ */
+class TypeProviderImpl implements TypeProvider {
+  /**
+   * The type representing the built-in type 'bool'.
+   */
+  InterfaceType _boolType;
+
+  /**
+   * The type representing the type 'bottom'.
+   */
+  DartType _bottomType;
+
+  /**
+   * The type representing the built-in type 'double'.
+   */
+  InterfaceType _doubleType;
+
+  /**
+   * The type representing the built-in type 'Deprecated'.
+   */
+  InterfaceType _deprecatedType;
+
+  /**
+   * The type representing the built-in type 'dynamic'.
+   */
+  DartType _dynamicType;
+
+  /**
+   * The type representing the built-in type 'Function'.
+   */
+  InterfaceType _functionType;
+
+  /**
+   * The type representing 'Future<dynamic>'.
+   */
+  InterfaceType _futureDynamicType;
+
+  /**
+   * The type representing 'Future<Null>'.
+   */
+  InterfaceType _futureNullType;
+
+  /**
+   * The type representing the built-in type 'Future'.
+   */
+  InterfaceType _futureType;
+
+  /**
+   * The type representing the built-in type 'int'.
+   */
+  InterfaceType _intType;
+
+  /**
+   * The type representing 'Iterable<dynamic>'.
+   */
+  InterfaceType _iterableDynamicType;
+
+  /**
+   * The type representing the built-in type 'Iterable'.
+   */
+  InterfaceType _iterableType;
+
+  /**
+   * The type representing the built-in type 'List'.
+   */
+  InterfaceType _listType;
+
+  /**
+   * The type representing the built-in type 'Map'.
+   */
+  InterfaceType _mapType;
+
+  /**
+   * An shared object representing the value 'null'.
+   */
+  DartObjectImpl _nullObject;
+
+  /**
+   * The type representing the type 'Null'.
+   */
+  InterfaceType _nullType;
+
+  /**
+   * The type representing the built-in type 'num'.
+   */
+  InterfaceType _numType;
+
+  /**
+   * The type representing the built-in type 'Object'.
+   */
+  InterfaceType _objectType;
+
+  /**
+   * The type representing the built-in type 'StackTrace'.
+   */
+  InterfaceType _stackTraceType;
+
+  /**
+   * The type representing 'Stream<dynamic>'.
+   */
+  InterfaceType _streamDynamicType;
+
+  /**
+   * The type representing the built-in type 'Stream'.
+   */
+  InterfaceType _streamType;
+
+  /**
+   * The type representing the built-in type 'String'.
+   */
+  InterfaceType _stringType;
+
+  /**
+   * The type representing the built-in type 'Symbol'.
+   */
+  InterfaceType _symbolType;
+
+  /**
+   * The type representing the built-in type 'Type'.
+   */
+  InterfaceType _typeType;
+
+  /**
+   * The type representing typenames that can't be resolved.
+   */
+  DartType _undefinedType;
+
+  /**
+   * Initialize a newly created type provider to provide the types defined in
+   * the given [coreLibrary] and [asyncLibrary].
+   */
+  TypeProviderImpl(LibraryElement coreLibrary, LibraryElement asyncLibrary) {
+    Namespace coreNamespace =
+        new NamespaceBuilder().createPublicNamespaceForLibrary(coreLibrary);
+    Namespace asyncNamespace =
+        new NamespaceBuilder().createPublicNamespaceForLibrary(asyncLibrary);
+    _initializeFrom(coreNamespace, asyncNamespace);
+  }
+
+  /**
+   * Initialize a newly created type provider to provide the types defined in
+   * the given [Namespace]s.
+   */
+  TypeProviderImpl.forNamespaces(
+      Namespace coreNamespace, Namespace asyncNamespace) {
+    _initializeFrom(coreNamespace, asyncNamespace);
+  }
+
+  @override
+  InterfaceType get boolType => _boolType;
+
+  @override
+  DartType get bottomType => _bottomType;
+
+  @override
+  InterfaceType get deprecatedType => _deprecatedType;
+
+  @override
+  InterfaceType get doubleType => _doubleType;
+
+  @override
+  DartType get dynamicType => _dynamicType;
+
+  @override
+  InterfaceType get functionType => _functionType;
+
+  @override
+  InterfaceType get futureDynamicType => _futureDynamicType;
+
+  @override
+  InterfaceType get futureNullType => _futureNullType;
+
+  @override
+  InterfaceType get futureType => _futureType;
+
+  @override
+  InterfaceType get intType => _intType;
+
+  @override
+  InterfaceType get iterableDynamicType => _iterableDynamicType;
+
+  @override
+  InterfaceType get iterableType => _iterableType;
+
+  @override
+  InterfaceType get listType => _listType;
+
+  @override
+  InterfaceType get mapType => _mapType;
+
+  @override
+  List<InterfaceType> get nonSubtypableTypes => <InterfaceType>[
+        nullType,
+        numType,
+        intType,
+        doubleType,
+        boolType,
+        stringType
+      ];
+
+  @override
+  DartObjectImpl get nullObject {
+    if (_nullObject == null) {
+      _nullObject = new DartObjectImpl(nullType, NullState.NULL_STATE);
+    }
+    return _nullObject;
+  }
+
+  @override
+  InterfaceType get nullType => _nullType;
+
+  @override
+  InterfaceType get numType => _numType;
+
+  @override
+  InterfaceType get objectType => _objectType;
+
+  @override
+  InterfaceType get stackTraceType => _stackTraceType;
+
+  @override
+  InterfaceType get streamDynamicType => _streamDynamicType;
+
+  @override
+  InterfaceType get streamType => _streamType;
+
+  @override
+  InterfaceType get stringType => _stringType;
+
+  @override
+  InterfaceType get symbolType => _symbolType;
+
+  @override
+  InterfaceType get typeType => _typeType;
+
+  @override
+  DartType get undefinedType => _undefinedType;
+
+  /**
+   * Return the type with the given name from the given namespace, or `null` if there is no
+   * class with the given name.
+   *
+   * @param namespace the namespace in which to search for the given name
+   * @param typeName the name of the type being searched for
+   * @return the type that was found
+   */
+  InterfaceType _getType(Namespace namespace, String typeName) {
+    Element element = namespace.get(typeName);
+    if (element == null) {
+      AnalysisEngine.instance.logger
+          .logInformation("No definition of type $typeName");
+      return null;
+    }
+    return (element as ClassElement).type;
+  }
+
+  /**
+   * Initialize the types provided by this type provider from the given
+   * [Namespace]s.
+   */
+  void _initializeFrom(Namespace coreNamespace, Namespace asyncNamespace) {
+    _boolType = _getType(coreNamespace, "bool");
+    _bottomType = BottomTypeImpl.instance;
+    _deprecatedType = _getType(coreNamespace, "Deprecated");
+    _doubleType = _getType(coreNamespace, "double");
+    _dynamicType = DynamicTypeImpl.instance;
+    _functionType = _getType(coreNamespace, "Function");
+    _futureType = _getType(asyncNamespace, "Future");
+    _intType = _getType(coreNamespace, "int");
+    _iterableType = _getType(coreNamespace, "Iterable");
+    _listType = _getType(coreNamespace, "List");
+    _mapType = _getType(coreNamespace, "Map");
+    _nullType = _getType(coreNamespace, "Null");
+    _numType = _getType(coreNamespace, "num");
+    _objectType = _getType(coreNamespace, "Object");
+    _stackTraceType = _getType(coreNamespace, "StackTrace");
+    _streamType = _getType(asyncNamespace, "Stream");
+    _stringType = _getType(coreNamespace, "String");
+    _symbolType = _getType(coreNamespace, "Symbol");
+    _typeType = _getType(coreNamespace, "Type");
+    _undefinedType = UndefinedTypeImpl.instance;
+    _futureDynamicType = _futureType.substitute4(<DartType>[_dynamicType]);
+    _futureNullType = _futureType.substitute4(<DartType>[_nullType]);
+    _iterableDynamicType = _iterableType.substitute4(<DartType>[_dynamicType]);
+    _streamDynamicType = _streamType.substitute4(<DartType>[_dynamicType]);
+  }
+}
+
+/**
+ * Instances of the class `TypeResolverVisitor` are used to resolve the types associated with
+ * the elements in the element model. This includes the types of superclasses, mixins, interfaces,
+ * fields, methods, parameters, and local variables. As a side-effect, this also finishes building
+ * the type hierarchy.
+ */
+class TypeResolverVisitor extends ScopedVisitor {
+  /**
+   * The type representing the type 'dynamic'.
+   */
+  DartType _dynamicType;
+
+  /**
+   * The type representing typenames that can't be resolved.
+   */
+  DartType _undefinedType;
+
+  /**
+   * The flag specifying if currently visited class references 'super' expression.
+   */
+  bool _hasReferenceToSuper = false;
+
+  /**
+   * Initialize a newly created visitor to resolve the nodes in an AST node.
+   *
+   * [definingLibrary] is the element for the library containing the node being
+   * visited.
+   * [source] is the source representing the compilation unit containing the
+   * node being visited.
+   * [typeProvider] is the object used to access the types from the core
+   * library.
+   * [errorListener] is the error listener that will be informed of any errors
+   * that are found during resolution.
+   * [nameScope] is the scope used to resolve identifiers in the node that will
+   * first be visited.  If `null` or unspecified, a new [LibraryScope] will be
+   * created based on [definingLibrary] and [typeProvider].
+   */
+  TypeResolverVisitor(LibraryElement definingLibrary, Source source,
+      TypeProvider typeProvider, AnalysisErrorListener errorListener,
+      {Scope nameScope})
+      : super(definingLibrary, source, typeProvider, errorListener,
+            nameScope: nameScope) {
+    _dynamicType = typeProvider.dynamicType;
+    _undefinedType = typeProvider.undefinedType;
+  }
+
+  @override
+  Object visitAnnotation(Annotation node) {
+    //
+    // Visit annotations, if the annotation is @proxy, on a class, and "proxy"
+    // resolves to the proxy annotation in dart.core, then create create the
+    // ElementAnnotationImpl and set it as the metadata on the enclosing class.
+    //
+    // Element resolution is done in the ElementResolver, and this work will be
+    // done in the general case for all annotations in the ElementResolver.
+    // The reason we resolve this particular element early is so that
+    // ClassElement.isProxy() returns the correct information during all
+    // phases of the ElementResolver.
+    //
+    super.visitAnnotation(node);
+    Identifier identifier = node.name;
+    if (identifier.name.endsWith(ElementAnnotationImpl.PROXY_VARIABLE_NAME) &&
+        node.parent is ClassDeclaration) {
+      Element element = nameScope.lookup(identifier, definingLibrary);
+      if (element != null &&
+          element.library.isDartCore &&
+          element is PropertyAccessorElement) {
+        // This is the @proxy from dart.core
+        ClassDeclaration classDeclaration = node.parent as ClassDeclaration;
+        ElementAnnotationImpl elementAnnotation =
+            new ElementAnnotationImpl(element);
+        node.elementAnnotation = elementAnnotation;
+        (classDeclaration.element as ClassElementImpl).metadata =
+            <ElementAnnotationImpl>[elementAnnotation];
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitCatchClause(CatchClause node) {
+    super.visitCatchClause(node);
+    SimpleIdentifier exception = node.exceptionParameter;
+    if (exception != null) {
+      // If an 'on' clause is provided the type of the exception parameter is
+      // the type in the 'on' clause. Otherwise, the type of the exception
+      // parameter is 'Object'.
+      TypeName exceptionTypeName = node.exceptionType;
+      DartType exceptionType;
+      if (exceptionTypeName == null) {
+        exceptionType = typeProvider.dynamicType;
+      } else {
+        exceptionType = _getType(exceptionTypeName);
+      }
+      _recordType(exception, exceptionType);
+      Element element = exception.staticElement;
+      if (element is VariableElementImpl) {
+        element.type = exceptionType;
+      } else {
+        // TODO(brianwilkerson) Report the internal error
+      }
+    }
+    SimpleIdentifier stackTrace = node.stackTraceParameter;
+    if (stackTrace != null) {
+      _recordType(stackTrace, typeProvider.stackTraceType);
+      Element element = stackTrace.staticElement;
+      if (element is VariableElementImpl) {
+        element.type = typeProvider.stackTraceType;
+      } else {
+        // TODO(brianwilkerson) Report the internal error
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitClassDeclaration(ClassDeclaration node) {
+    _hasReferenceToSuper = false;
+    super.visitClassDeclaration(node);
+    ClassElementImpl classElement = _getClassElement(node.name);
+    if (classElement != null) {
+      classElement.hasReferenceToSuper = _hasReferenceToSuper;
+    }
+    return null;
+  }
+
+  @override
+  void visitClassDeclarationInScope(ClassDeclaration node) {
+    super.visitClassDeclarationInScope(node);
+    ExtendsClause extendsClause = node.extendsClause;
+    WithClause withClause = node.withClause;
+    ImplementsClause implementsClause = node.implementsClause;
+    ClassElementImpl classElement = _getClassElement(node.name);
+    InterfaceType superclassType = null;
+    if (extendsClause != null) {
+      ErrorCode errorCode = (withClause == null
+          ? CompileTimeErrorCode.EXTENDS_NON_CLASS
+          : CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS);
+      superclassType = _resolveType(extendsClause.superclass, errorCode,
+          CompileTimeErrorCode.EXTENDS_ENUM, errorCode);
+      if (!identical(superclassType, typeProvider.objectType)) {
+        classElement.validMixin = false;
+      }
+    }
+    if (classElement != null) {
+      if (superclassType == null) {
+        InterfaceType objectType = typeProvider.objectType;
+        if (!identical(classElement.type, objectType)) {
+          superclassType = objectType;
+        }
+      }
+      classElement.supertype = superclassType;
+    }
+    _resolve(classElement, withClause, implementsClause);
+    return null;
+  }
+
+  @override
+  void visitClassMembersInScope(ClassDeclaration node) {
+    //
+    // Process field declarations before constructors and methods so that the
+    // types of field formal parameters can be correctly resolved.
+    //
+    List<ClassMember> nonFields = new List<ClassMember>();
+    node.visitChildren(
+        new _TypeResolverVisitor_visitClassMembersInScope(this, nonFields));
+    int count = nonFields.length;
+    for (int i = 0; i < count; i++) {
+      nonFields[i].accept(this);
+    }
+  }
+
+  @override
+  Object visitClassTypeAlias(ClassTypeAlias node) {
+    super.visitClassTypeAlias(node);
+    ErrorCode errorCode = CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS;
+    InterfaceType superclassType = _resolveType(node.superclass, errorCode,
+        CompileTimeErrorCode.EXTENDS_ENUM, errorCode);
+    if (superclassType == null) {
+      superclassType = typeProvider.objectType;
+    }
+    ClassElementImpl classElement = _getClassElement(node.name);
+    if (classElement != null) {
+      classElement.supertype = superclassType;
+    }
+    _resolve(classElement, node.withClause, node.implementsClause);
+    return null;
+  }
+
+  @override
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    super.visitConstructorDeclaration(node);
+    ExecutableElementImpl element = node.element as ExecutableElementImpl;
+    if (element == null) {
+      ClassDeclaration classNode =
+          node.getAncestor((node) => node is ClassDeclaration);
+      StringBuffer buffer = new StringBuffer();
+      buffer.write("The element for the constructor ");
+      buffer.write(node.name == null ? "<unnamed>" : node.name.name);
+      buffer.write(" in ");
+      if (classNode == null) {
+        buffer.write("<unknown class>");
+      } else {
+        buffer.write(classNode.name.name);
+      }
+      buffer.write(" in ");
+      buffer.write(source.fullName);
+      buffer.write(" was not set while trying to resolve types.");
+      AnalysisEngine.instance.logger.logError(buffer.toString(),
+          new CaughtException(new AnalysisException(), null));
+    } else {
+      ClassElement definingClass = element.enclosingElement as ClassElement;
+      element.returnType = definingClass.type;
+      FunctionTypeImpl type = new FunctionTypeImpl(element);
+      type.typeArguments = definingClass.type.typeArguments;
+      element.type = type;
+    }
+    return null;
+  }
+
+  @override
+  Object visitDeclaredIdentifier(DeclaredIdentifier node) {
+    super.visitDeclaredIdentifier(node);
+    DartType declaredType;
+    TypeName typeName = node.type;
+    if (typeName == null) {
+      declaredType = _dynamicType;
+    } else {
+      declaredType = _getType(typeName);
+    }
+    LocalVariableElementImpl element = node.element as LocalVariableElementImpl;
+    element.type = declaredType;
+    return null;
+  }
+
+  @override
+  Object visitFieldFormalParameter(FieldFormalParameter node) {
+    super.visitFieldFormalParameter(node);
+    Element element = node.identifier.staticElement;
+    if (element is ParameterElementImpl) {
+      ParameterElementImpl parameter = element;
+      FormalParameterList parameterList = node.parameters;
+      if (parameterList == null) {
+        DartType type;
+        TypeName typeName = node.type;
+        if (typeName == null) {
+          type = _dynamicType;
+          if (parameter is FieldFormalParameterElement) {
+            FieldElement fieldElement =
+                (parameter as FieldFormalParameterElement).field;
+            if (fieldElement != null) {
+              type = fieldElement.type;
+            }
+          }
+        } else {
+          type = _getType(typeName);
+        }
+        parameter.type = type;
+      } else {
+        _setFunctionTypedParameterType(parameter, node.type, node.parameters);
+      }
+    } else {
+      // TODO(brianwilkerson) Report this internal error
+    }
+    return null;
+  }
+
+  @override
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    super.visitFunctionDeclaration(node);
+    ExecutableElementImpl element = node.element as ExecutableElementImpl;
+    if (element == null) {
+      StringBuffer buffer = new StringBuffer();
+      buffer.write("The element for the top-level function ");
+      buffer.write(node.name);
+      buffer.write(" in ");
+      buffer.write(source.fullName);
+      buffer.write(" was not set while trying to resolve types.");
+      AnalysisEngine.instance.logger.logError(buffer.toString(),
+          new CaughtException(new AnalysisException(), null));
+    }
+    element.returnType = _computeReturnType(node.returnType);
+    FunctionTypeImpl type = new FunctionTypeImpl(element);
+    ClassElement definingClass =
+        element.getAncestor((element) => element is ClassElement);
+    if (definingClass != null) {
+      type.typeArguments = definingClass.type.typeArguments;
+    }
+    element.type = type;
+    return null;
+  }
+
+  @override
+  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+    FunctionTypeAliasElementImpl element =
+        node.element as FunctionTypeAliasElementImpl;
+    super.visitFunctionTypeAlias(node);
+    element.returnType = _computeReturnType(node.returnType);
+    return null;
+  }
+
+  @override
+  Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
+    super.visitFunctionTypedFormalParameter(node);
+    Element element = node.identifier.staticElement;
+    if (element is ParameterElementImpl) {
+      _setFunctionTypedParameterType(element, node.returnType, node.parameters);
+    } else {
+      // TODO(brianwilkerson) Report this internal error
+    }
+    return null;
+  }
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    super.visitMethodDeclaration(node);
+    ExecutableElementImpl element = node.element as ExecutableElementImpl;
+    if (element == null) {
+      ClassDeclaration classNode =
+          node.getAncestor((node) => node is ClassDeclaration);
+      StringBuffer buffer = new StringBuffer();
+      buffer.write("The element for the method ");
+      buffer.write(node.name.name);
+      buffer.write(" in ");
+      if (classNode == null) {
+        buffer.write("<unknown class>");
+      } else {
+        buffer.write(classNode.name.name);
+      }
+      buffer.write(" in ");
+      buffer.write(source.fullName);
+      buffer.write(" was not set while trying to resolve types.");
+      AnalysisEngine.instance.logger.logError(buffer.toString(),
+          new CaughtException(new AnalysisException(), null));
+    }
+    element.returnType = _computeReturnType(node.returnType);
+    FunctionTypeImpl type = new FunctionTypeImpl(element);
+    ClassElement definingClass =
+        element.getAncestor((element) => element is ClassElement);
+    if (definingClass != null) {
+      type.typeArguments = definingClass.type.typeArguments;
+    }
+    element.type = type;
+    if (element is PropertyAccessorElement) {
+      PropertyAccessorElement accessor = element as PropertyAccessorElement;
+      PropertyInducingElementImpl variable =
+          accessor.variable as PropertyInducingElementImpl;
+      if (accessor.isGetter) {
+        variable.type = type.returnType;
+      } else if (variable.type == null) {
+        List<DartType> parameterTypes = type.normalParameterTypes;
+        if (parameterTypes != null && parameterTypes.length > 0) {
+          variable.type = parameterTypes[0];
+        }
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitSimpleFormalParameter(SimpleFormalParameter node) {
+    super.visitSimpleFormalParameter(node);
+    DartType declaredType;
+    TypeName typeName = node.type;
+    if (typeName == null) {
+      declaredType = _dynamicType;
+    } else {
+      declaredType = _getType(typeName);
+    }
+    Element element = node.identifier.staticElement;
+    if (element is ParameterElement) {
+      (element as ParameterElementImpl).type = declaredType;
+    } else {
+      // TODO(brianwilkerson) Report the internal error.
+    }
+    return null;
+  }
+
+  @override
+  Object visitSuperExpression(SuperExpression node) {
+    _hasReferenceToSuper = true;
+    return super.visitSuperExpression(node);
+  }
+
+  @override
+  Object visitTypeName(TypeName node) {
+    super.visitTypeName(node);
+    Identifier typeName = node.name;
+    TypeArgumentList argumentList = node.typeArguments;
+    Element element = nameScope.lookup(typeName, definingLibrary);
+    if (element == null) {
+      //
+      // Check to see whether the type name is either 'dynamic' or 'void',
+      // neither of which are in the name scope and hence will not be found by
+      // normal means.
+      //
+      if (typeName.name == _dynamicType.name) {
+        _setElement(typeName, _dynamicType.element);
+        if (argumentList != null) {
+          // TODO(brianwilkerson) Report this error
+//          reporter.reportError(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, node, dynamicType.getName(), 0, argumentList.getArguments().size());
+        }
+        typeName.staticType = _dynamicType;
+        node.type = _dynamicType;
+        return null;
+      }
+      VoidTypeImpl voidType = VoidTypeImpl.instance;
+      if (typeName.name == voidType.name) {
+        // There is no element for 'void'.
+        if (argumentList != null) {
+          // TODO(brianwilkerson) Report this error
+//          reporter.reportError(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, node, voidType.getName(), 0, argumentList.getArguments().size());
+        }
+        typeName.staticType = voidType;
+        node.type = voidType;
+        return null;
+      }
+      //
+      // If not, the look to see whether we might have created the wrong AST
+      // structure for a constructor name. If so, fix the AST structure and then
+      // proceed.
+      //
+      AstNode parent = node.parent;
+      if (typeName is PrefixedIdentifier &&
+          parent is ConstructorName &&
+          argumentList == null) {
+        ConstructorName name = parent;
+        if (name.name == null) {
+          PrefixedIdentifier prefixedIdentifier =
+              typeName as PrefixedIdentifier;
+          SimpleIdentifier prefix = prefixedIdentifier.prefix;
+          element = nameScope.lookup(prefix, definingLibrary);
+          if (element is PrefixElement) {
+            if (parent.parent is InstanceCreationExpression &&
+                (parent.parent as InstanceCreationExpression).isConst) {
+              // If, if this is a const expression, then generate a
+              // CompileTimeErrorCode.CONST_WITH_NON_TYPE error.
+              reportErrorForNode(
+                  CompileTimeErrorCode.CONST_WITH_NON_TYPE,
+                  prefixedIdentifier.identifier,
+                  [prefixedIdentifier.identifier.name]);
+            } else {
+              // Else, if this expression is a new expression, report a
+              // NEW_WITH_NON_TYPE warning.
+              reportErrorForNode(
+                  StaticWarningCode.NEW_WITH_NON_TYPE,
+                  prefixedIdentifier.identifier,
+                  [prefixedIdentifier.identifier.name]);
+            }
+            _setElement(prefix, element);
+            return null;
+          } else if (element != null) {
+            //
+            // Rewrite the constructor name. The parser, when it sees a
+            // constructor named "a.b", cannot tell whether "a" is a prefix and
+            // "b" is a class name, or whether "a" is a class name and "b" is a
+            // constructor name. It arbitrarily chooses the former, but in this
+            // case was wrong.
+            //
+            name.name = prefixedIdentifier.identifier;
+            name.period = prefixedIdentifier.period;
+            node.name = prefix;
+            typeName = prefix;
+          }
+        }
+      }
+    }
+    // check element
+    bool elementValid = element is! MultiplyDefinedElement;
+    if (elementValid &&
+        element is! ClassElement &&
+        _isTypeNameInInstanceCreationExpression(node)) {
+      SimpleIdentifier typeNameSimple = _getTypeSimpleIdentifier(typeName);
+      InstanceCreationExpression creation =
+          node.parent.parent as InstanceCreationExpression;
+      if (creation.isConst) {
+        if (element == null) {
+          reportErrorForNode(
+              CompileTimeErrorCode.UNDEFINED_CLASS, typeNameSimple, [typeName]);
+        } else {
+          reportErrorForNode(CompileTimeErrorCode.CONST_WITH_NON_TYPE,
+              typeNameSimple, [typeName]);
+        }
+        elementValid = false;
+      } else {
+        if (element != null) {
+          reportErrorForNode(
+              StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
+          elementValid = false;
+        }
+      }
+    }
+    if (elementValid && element == null) {
+      // We couldn't resolve the type name.
+      // TODO(jwren) Consider moving the check for
+      // CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE from the
+      // ErrorVerifier, so that we don't have two errors on a built in
+      // identifier being used as a class name.
+      // See CompileTimeErrorCodeTest.test_builtInIdentifierAsType().
+      SimpleIdentifier typeNameSimple = _getTypeSimpleIdentifier(typeName);
+      RedirectingConstructorKind redirectingConstructorKind;
+      if (_isBuiltInIdentifier(node) && _isTypeAnnotation(node)) {
+        reportErrorForNode(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE,
+            typeName, [typeName.name]);
+      } else if (typeNameSimple.name == "boolean") {
+        reportErrorForNode(
+            StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, typeNameSimple, []);
+      } else if (_isTypeNameInCatchClause(node)) {
+        reportErrorForNode(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName,
+            [typeName.name]);
+      } else if (_isTypeNameInAsExpression(node)) {
+        reportErrorForNode(
+            StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
+      } else if (_isTypeNameInIsExpression(node)) {
+        reportErrorForNode(StaticWarningCode.TYPE_TEST_WITH_UNDEFINED_NAME,
+            typeName, [typeName.name]);
+      } else if ((redirectingConstructorKind =
+              _getRedirectingConstructorKind(node)) !=
+          null) {
+        ErrorCode errorCode = (redirectingConstructorKind ==
+                RedirectingConstructorKind.CONST
+            ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS
+            : StaticWarningCode.REDIRECT_TO_NON_CLASS);
+        reportErrorForNode(errorCode, typeName, [typeName.name]);
+      } else if (_isTypeNameInTypeArgumentList(node)) {
+        reportErrorForNode(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
+            typeName, [typeName.name]);
+      } else {
+        reportErrorForNode(
+            StaticWarningCode.UNDEFINED_CLASS, typeName, [typeName.name]);
+      }
+      elementValid = false;
+    }
+    if (!elementValid) {
+      if (element is MultiplyDefinedElement) {
+        _setElement(typeName, element);
+      } else {
+        _setElement(typeName, _dynamicType.element);
+      }
+      typeName.staticType = _undefinedType;
+      node.type = _undefinedType;
+      return null;
+    }
+    DartType type = null;
+    if (element is ClassElement) {
+      _setElement(typeName, element);
+      type = element.type;
+    } else if (element is FunctionTypeAliasElement) {
+      _setElement(typeName, element);
+      type = element.type;
+    } else if (element is TypeParameterElement) {
+      _setElement(typeName, element);
+      type = element.type;
+      if (argumentList != null) {
+        // Type parameters cannot have type arguments.
+        // TODO(brianwilkerson) Report this error.
+        //      resolver.reportError(ResolverErrorCode.?, keyType);
+      }
+    } else if (element is MultiplyDefinedElement) {
+      List<Element> elements = element.conflictingElements;
+      type = _getTypeWhenMultiplyDefined(elements);
+      if (type != null) {
+        node.type = type;
+      }
+    } else {
+      // The name does not represent a type.
+      RedirectingConstructorKind redirectingConstructorKind;
+      if (_isTypeNameInCatchClause(node)) {
+        reportErrorForNode(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName,
+            [typeName.name]);
+      } else if (_isTypeNameInAsExpression(node)) {
+        reportErrorForNode(
+            StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
+      } else if (_isTypeNameInIsExpression(node)) {
+        reportErrorForNode(StaticWarningCode.TYPE_TEST_WITH_NON_TYPE, typeName,
+            [typeName.name]);
+      } else if ((redirectingConstructorKind =
+              _getRedirectingConstructorKind(node)) !=
+          null) {
+        ErrorCode errorCode = (redirectingConstructorKind ==
+                RedirectingConstructorKind.CONST
+            ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS
+            : StaticWarningCode.REDIRECT_TO_NON_CLASS);
+        reportErrorForNode(errorCode, typeName, [typeName.name]);
+      } else if (_isTypeNameInTypeArgumentList(node)) {
+        reportErrorForNode(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
+            typeName, [typeName.name]);
+      } else {
+        AstNode parent = typeName.parent;
+        while (parent is TypeName) {
+          parent = parent.parent;
+        }
+        if (parent is ExtendsClause ||
+            parent is ImplementsClause ||
+            parent is WithClause ||
+            parent is ClassTypeAlias) {
+          // Ignored. The error will be reported elsewhere.
+        } else {
+          reportErrorForNode(
+              StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
+        }
+      }
+      _setElement(typeName, _dynamicType.element);
+      typeName.staticType = _dynamicType;
+      node.type = _dynamicType;
+      return null;
+    }
+    if (argumentList != null) {
+      NodeList<TypeName> arguments = argumentList.arguments;
+      int argumentCount = arguments.length;
+      List<DartType> parameters = _getTypeArguments(type);
+      int parameterCount = parameters.length;
+      List<DartType> typeArguments = new List<DartType>(parameterCount);
+      if (argumentCount == parameterCount) {
+        for (int i = 0; i < parameterCount; i++) {
+          TypeName argumentTypeName = arguments[i];
+          DartType argumentType = _getType(argumentTypeName);
+          if (argumentType == null) {
+            argumentType = _dynamicType;
+          }
+          typeArguments[i] = argumentType;
+        }
+      } else {
+        reportErrorForNode(_getInvalidTypeParametersErrorCode(node), node,
+            [typeName.name, parameterCount, argumentCount]);
+        for (int i = 0; i < parameterCount; i++) {
+          typeArguments[i] = _dynamicType;
+        }
+      }
+      if (type is InterfaceTypeImpl) {
+        InterfaceTypeImpl interfaceType = type as InterfaceTypeImpl;
+        type = interfaceType.substitute4(typeArguments);
+      } else if (type is FunctionTypeImpl) {
+        FunctionTypeImpl functionType = type as FunctionTypeImpl;
+        type = functionType.substitute3(typeArguments);
+      } else {
+        // TODO(brianwilkerson) Report this internal error.
+      }
+    } else {
+      //
+      // Check for the case where there are no type arguments given for a
+      // parameterized type.
+      //
+      List<DartType> parameters = _getTypeArguments(type);
+      int parameterCount = parameters.length;
+      if (parameterCount > 0) {
+        DynamicTypeImpl dynamicType = DynamicTypeImpl.instance;
+        List<DartType> arguments = new List<DartType>(parameterCount);
+        for (int i = 0; i < parameterCount; i++) {
+          arguments[i] = dynamicType;
+        }
+        type = type.substitute2(arguments, parameters);
+      }
+    }
+    typeName.staticType = type;
+    node.type = type;
+    return null;
+  }
+
+  @override
+  Object visitTypeParameter(TypeParameter node) {
+    super.visitTypeParameter(node);
+    TypeName bound = node.bound;
+    if (bound != null) {
+      TypeParameterElementImpl typeParameter =
+          node.name.staticElement as TypeParameterElementImpl;
+      if (typeParameter != null) {
+        typeParameter.bound = bound.type;
+      }
+    }
+    return null;
+  }
+
+  @override
+  Object visitVariableDeclaration(VariableDeclaration node) {
+    super.visitVariableDeclaration(node);
+    DartType declaredType;
+    TypeName typeName = (node.parent as VariableDeclarationList).type;
+    if (typeName == null) {
+      declaredType = _dynamicType;
+    } else {
+      declaredType = _getType(typeName);
+    }
+    Element element = node.name.staticElement;
+    if (element is VariableElement) {
+      (element as VariableElementImpl).type = declaredType;
+      if (element is PropertyInducingElement) {
+        PropertyInducingElement variableElement = element;
+        PropertyAccessorElementImpl getter =
+            variableElement.getter as PropertyAccessorElementImpl;
+        getter.returnType = declaredType;
+        FunctionTypeImpl getterType = new FunctionTypeImpl(getter);
+        ClassElement definingClass =
+            element.getAncestor((element) => element is ClassElement);
+        if (definingClass != null) {
+          getterType.typeArguments = definingClass.type.typeArguments;
+        }
+        getter.type = getterType;
+        PropertyAccessorElementImpl setter =
+            variableElement.setter as PropertyAccessorElementImpl;
+        if (setter != null) {
+          List<ParameterElement> parameters = setter.parameters;
+          if (parameters.length > 0) {
+            (parameters[0] as ParameterElementImpl).type = declaredType;
+          }
+          setter.returnType = VoidTypeImpl.instance;
+          FunctionTypeImpl setterType = new FunctionTypeImpl(setter);
+          if (definingClass != null) {
+            setterType.typeArguments = definingClass.type.typeArguments;
+          }
+          setter.type = setterType;
+        }
+      }
+    } else {
+      // TODO(brianwilkerson) Report the internal error.
+    }
+    return null;
+  }
+
+  /**
+   * Given a type name representing the return type of a function, compute the return type of the
+   * function.
+   *
+   * @param returnType the type name representing the return type of the function
+   * @return the return type that was computed
+   */
+  DartType _computeReturnType(TypeName returnType) {
+    if (returnType == null) {
+      return _dynamicType;
+    } else {
+      return returnType.type;
+    }
+  }
+
+  /**
+   * 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.
+      return null;
+    }
+    Element element = identifier.staticElement;
+    if (element is! ClassElementImpl) {
+      // TODO(brianwilkerson) Report this
+      // Internal error: Failed to create an element for a class declaration.
+      return null;
+    }
+    return element as ClassElementImpl;
+  }
+
+  /**
+   * Return an array containing all of the elements associated with the parameters in the given
+   * list.
+   *
+   * @param parameterList the list of parameters whose elements are to be returned
+   * @return the elements associated with the parameters
+   */
+  List<ParameterElement> _getElements(FormalParameterList parameterList) {
+    List<ParameterElement> elements = new List<ParameterElement>();
+    for (FormalParameter parameter in parameterList.parameters) {
+      ParameterElement element =
+          parameter.identifier.staticElement as ParameterElement;
+      // TODO(brianwilkerson) Understand why the element would be null.
+      if (element != null) {
+        elements.add(element);
+      }
+    }
+    return elements;
+  }
+
+  /**
+   * The number of type arguments in the given type name does not match the number of parameters in
+   * the corresponding class element. Return the error code that should be used to report this
+   * error.
+   *
+   * @param node the type name with the wrong number of type arguments
+   * @return the error code that should be used to report that the wrong number of type arguments
+   *         were provided
+   */
+  ErrorCode _getInvalidTypeParametersErrorCode(TypeName node) {
+    AstNode parent = node.parent;
+    if (parent is ConstructorName) {
+      parent = parent.parent;
+      if (parent is InstanceCreationExpression) {
+        if (parent.isConst) {
+          return CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS;
+        } else {
+          return StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS;
+        }
+      }
+    }
+    return StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
+  }
+
+  /**
+   * Checks if the given type name is the target in a redirected constructor.
+   *
+   * @param typeName the type name to analyze
+   * @return some [RedirectingConstructorKind] if the given type name is used as the type in a
+   *         redirected constructor, or `null` otherwise
+   */
+  RedirectingConstructorKind _getRedirectingConstructorKind(TypeName typeName) {
+    AstNode parent = typeName.parent;
+    if (parent is ConstructorName) {
+      ConstructorName constructorName = parent as ConstructorName;
+      parent = constructorName.parent;
+      if (parent is ConstructorDeclaration) {
+        if (identical(parent.redirectedConstructor, constructorName)) {
+          if (parent.constKeyword != null) {
+            return RedirectingConstructorKind.CONST;
+          }
+          return RedirectingConstructorKind.NORMAL;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the type represented by the given type name.
+   *
+   * @param typeName the type name representing the type to be returned
+   * @return the type represented by the type name
+   */
+  DartType _getType(TypeName typeName) {
+    DartType type = typeName.type;
+    if (type == null) {
+      return _undefinedType;
+    }
+    return type;
+  }
+
+  /**
+   * Return the type arguments associated with the given type.
+   *
+   * @param type the type whole type arguments are to be returned
+   * @return the type arguments associated with the given type
+   */
+  List<DartType> _getTypeArguments(DartType type) {
+    if (type is InterfaceType) {
+      return type.typeArguments;
+    } else if (type is FunctionType) {
+      return type.typeArguments;
+    }
+    return DartType.EMPTY_LIST;
+  }
+
+  /**
+   * Returns the simple identifier of the given (may be qualified) type name.
+   *
+   * @param typeName the (may be qualified) qualified type name
+   * @return the simple identifier of the given (may be qualified) type name.
+   */
+  SimpleIdentifier _getTypeSimpleIdentifier(Identifier typeName) {
+    if (typeName is SimpleIdentifier) {
+      return typeName;
+    } else {
+      return (typeName as PrefixedIdentifier).identifier;
+    }
+  }
+
+  /**
+   * Given the multiple elements to which a single name could potentially be resolved, return the
+   * single interface type that should be used, or `null` if there is no clear choice.
+   *
+   * @param elements the elements to which a single name could potentially be resolved
+   * @return the single interface type that should be used for the type name
+   */
+  InterfaceType _getTypeWhenMultiplyDefined(List<Element> elements) {
+    InterfaceType type = null;
+    for (Element element in elements) {
+      if (element is ClassElement) {
+        if (type != null) {
+          return null;
+        }
+        type = element.type;
+      }
+    }
+    return type;
+  }
+
+  /**
+   * Checks if the given type name is used as the type in an as expression.
+   *
+   * @param typeName the type name to analyzer
+   * @return `true` if the given type name is used as the type in an as expression
+   */
+  bool _isTypeNameInAsExpression(TypeName typeName) {
+    AstNode parent = typeName.parent;
+    if (parent is AsExpression) {
+      AsExpression asExpression = parent;
+      return identical(asExpression.type, typeName);
+    }
+    return false;
+  }
+
+  /**
+   * Checks if the given type name is used as the exception type in a catch clause.
+   *
+   * @param typeName the type name to analyzer
+   * @return `true` if the given type name is used as the exception type in a catch clause
+   */
+  bool _isTypeNameInCatchClause(TypeName typeName) {
+    AstNode parent = typeName.parent;
+    if (parent is CatchClause) {
+      CatchClause catchClause = parent;
+      return identical(catchClause.exceptionType, typeName);
+    }
+    return false;
+  }
+
+  /**
+   * Checks if the given type name is used as the type in an instance creation expression.
+   *
+   * @param typeName the type name to analyzer
+   * @return `true` if the given type name is used as the type in an instance creation
+   *         expression
+   */
+  bool _isTypeNameInInstanceCreationExpression(TypeName typeName) {
+    AstNode parent = typeName.parent;
+    if (parent is ConstructorName &&
+        parent.parent is InstanceCreationExpression) {
+      ConstructorName constructorName = parent;
+      return constructorName != null &&
+          identical(constructorName.type, typeName);
+    }
+    return false;
+  }
+
+  /**
+   * Checks if the given type name is used as the type in an is expression.
+   *
+   * @param typeName the type name to analyzer
+   * @return `true` if the given type name is used as the type in an is expression
+   */
+  bool _isTypeNameInIsExpression(TypeName typeName) {
+    AstNode parent = typeName.parent;
+    if (parent is IsExpression) {
+      IsExpression isExpression = parent;
+      return identical(isExpression.type, typeName);
+    }
+    return false;
+  }
+
+  /**
+   * Checks if the given type name used in a type argument list.
+   *
+   * @param typeName the type name to analyzer
+   * @return `true` if the given type name is in a type argument list
+   */
+  bool _isTypeNameInTypeArgumentList(TypeName typeName) =>
+      typeName.parent is TypeArgumentList;
+
+  /**
+   * Record that the static type of the given node is the given type.
+   *
+   * @param expression the node whose type is to be recorded
+   * @param type the static type of the node
+   */
+  Object _recordType(Expression expression, DartType type) {
+    if (type == null) {
+      expression.staticType = _dynamicType;
+    } else {
+      expression.staticType = type;
+    }
+    return null;
+  }
+
+  /**
+   * Resolve the types in the given with and implements clauses and associate those types with the
+   * given class element.
+   *
+   * @param classElement the class element with which the mixin and interface types are to be
+   *          associated
+   * @param withClause the with clause to be resolved
+   * @param implementsClause the implements clause to be resolved
+   */
+  void _resolve(ClassElementImpl classElement, WithClause withClause,
+      ImplementsClause implementsClause) {
+    if (withClause != null) {
+      List<InterfaceType> mixinTypes = _resolveTypes(
+          withClause.mixinTypes,
+          CompileTimeErrorCode.MIXIN_OF_NON_CLASS,
+          CompileTimeErrorCode.MIXIN_OF_ENUM,
+          CompileTimeErrorCode.MIXIN_OF_NON_CLASS);
+      if (classElement != null) {
+        classElement.mixins = mixinTypes;
+        classElement.withClauseRange =
+            new SourceRange(withClause.offset, withClause.length);
+      }
+    }
+    if (implementsClause != null) {
+      NodeList<TypeName> interfaces = implementsClause.interfaces;
+      List<InterfaceType> interfaceTypes = _resolveTypes(
+          interfaces,
+          CompileTimeErrorCode.IMPLEMENTS_NON_CLASS,
+          CompileTimeErrorCode.IMPLEMENTS_ENUM,
+          CompileTimeErrorCode.IMPLEMENTS_DYNAMIC);
+      if (classElement != null) {
+        classElement.interfaces = interfaceTypes;
+      }
+      // TODO(brianwilkerson) Move the following checks to ErrorVerifier.
+      int count = interfaces.length;
+      List<bool> detectedRepeatOnIndex = new List<bool>.filled(count, false);
+      for (int i = 0; i < detectedRepeatOnIndex.length; i++) {
+        detectedRepeatOnIndex[i] = false;
+      }
+      for (int i = 0; i < count; i++) {
+        TypeName typeName = interfaces[i];
+        if (!detectedRepeatOnIndex[i]) {
+          Element element = typeName.name.staticElement;
+          for (int j = i + 1; j < count; j++) {
+            TypeName typeName2 = interfaces[j];
+            Identifier identifier2 = typeName2.name;
+            String name2 = identifier2.name;
+            Element element2 = identifier2.staticElement;
+            if (element != null && element == element2) {
+              detectedRepeatOnIndex[j] = true;
+              reportErrorForNode(
+                  CompileTimeErrorCode.IMPLEMENTS_REPEATED, typeName2, [name2]);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Return the type specified by the given name.
+   *
+   * @param typeName the type name specifying the type to be returned
+   * @param nonTypeError the error to produce if the type name is defined to be something other than
+   *          a type
+   * @param enumTypeError the error to produce if the type name is defined to be an enum
+   * @param dynamicTypeError the error to produce if the type name is "dynamic"
+   * @return the type specified by the type name
+   */
+  InterfaceType _resolveType(TypeName typeName, ErrorCode nonTypeError,
+      ErrorCode enumTypeError, ErrorCode dynamicTypeError) {
+    DartType type = typeName.type;
+    if (type is InterfaceType) {
+      ClassElement element = type.element;
+      if (element != null && element.isEnum) {
+        reportErrorForNode(enumTypeError, typeName);
+        return null;
+      }
+      return type;
+    }
+    // If the type is not an InterfaceType, then visitTypeName() sets the type
+    // to be a DynamicTypeImpl
+    Identifier name = typeName.name;
+    if (name.name == sc.Keyword.DYNAMIC.syntax) {
+      reportErrorForNode(dynamicTypeError, name, [name.name]);
+    } else {
+      reportErrorForNode(nonTypeError, name, [name.name]);
+    }
+    return null;
+  }
+
+  /**
+   * Resolve the types in the given list of type names.
+   *
+   * @param typeNames the type names to be resolved
+   * @param nonTypeError the error to produce if the type name is defined to be something other than
+   *          a type
+   * @param enumTypeError the error to produce if the type name is defined to be an enum
+   * @param dynamicTypeError the error to produce if the type name is "dynamic"
+   * @return an array containing all of the types that were resolved.
+   */
+  List<InterfaceType> _resolveTypes(
+      NodeList<TypeName> typeNames,
+      ErrorCode nonTypeError,
+      ErrorCode enumTypeError,
+      ErrorCode dynamicTypeError) {
+    List<InterfaceType> types = new List<InterfaceType>();
+    for (TypeName typeName in typeNames) {
+      InterfaceType type =
+          _resolveType(typeName, nonTypeError, enumTypeError, dynamicTypeError);
+      if (type != null) {
+        types.add(type);
+      }
+    }
+    return types;
+  }
+
+  void _setElement(Identifier typeName, Element element) {
+    if (element != null) {
+      if (typeName is SimpleIdentifier) {
+        typeName.staticElement = element;
+      } else if (typeName is PrefixedIdentifier) {
+        PrefixedIdentifier identifier = typeName;
+        identifier.identifier.staticElement = element;
+        SimpleIdentifier prefix = identifier.prefix;
+        Element prefixElement = nameScope.lookup(prefix, definingLibrary);
+        if (prefixElement != null) {
+          prefix.staticElement = prefixElement;
+        }
+      }
+    }
+  }
+
+  /**
+   * Given a parameter element, create a function type based on the given return type and parameter
+   * list and associate the created type with the element.
+   *
+   * @param element the parameter element whose type is to be set
+   * @param returnType the (possibly `null`) return type of the function
+   * @param parameterList the list of parameters to the function
+   */
+  void _setFunctionTypedParameterType(ParameterElementImpl element,
+      TypeName returnType, FormalParameterList parameterList) {
+    List<ParameterElement> parameters = _getElements(parameterList);
+    FunctionTypeAliasElementImpl aliasElement =
+        new FunctionTypeAliasElementImpl.forNode(null);
+    aliasElement.synthetic = true;
+    aliasElement.shareParameters(parameters);
+    aliasElement.returnType = _computeReturnType(returnType);
+    // FunctionTypeAliasElementImpl assumes the enclosing element is a
+    // CompilationUnitElement (because non-synthetic function types can only be
+    // declared at top level), so to avoid breaking things, go find the
+    // compilation unit element.
+    aliasElement.enclosingElement =
+        element.getAncestor((element) => element is CompilationUnitElement);
+    FunctionTypeImpl type = new FunctionTypeImpl.forTypedef(aliasElement);
+    ClassElement definingClass =
+        element.getAncestor((element) => element is ClassElement);
+    if (definingClass != null) {
+      aliasElement.shareTypeParameters(definingClass.typeParameters);
+      type.typeArguments = definingClass.type.typeArguments;
+    } else {
+      FunctionTypeAliasElement alias =
+          element.getAncestor((element) => element is FunctionTypeAliasElement);
+      while (alias != null && alias.isSynthetic) {
+        alias =
+            alias.getAncestor((element) => element is FunctionTypeAliasElement);
+      }
+      if (alias != null) {
+        aliasElement.typeParameters = alias.typeParameters;
+        type.typeArguments = alias.type.typeArguments;
+      } else {
+        type.typeArguments = DartType.EMPTY_LIST;
+      }
+    }
+    element.type = type;
+  }
+
+  /**
+   * @return `true` if the name of the given [TypeName] is an built-in identifier.
+   */
+  static bool _isBuiltInIdentifier(TypeName node) {
+    sc.Token token = node.name.beginToken;
+    return token.type == sc.TokenType.KEYWORD;
+  }
+
+  /**
+   * @return `true` if given [TypeName] is used as a type annotation.
+   */
+  static bool _isTypeAnnotation(TypeName node) {
+    AstNode parent = node.parent;
+    if (parent is VariableDeclarationList) {
+      return identical(parent.type, node);
+    }
+    if (parent is FieldFormalParameter) {
+      return identical(parent.type, node);
+    }
+    if (parent is SimpleFormalParameter) {
+      return identical(parent.type, node);
+    }
+    return false;
+  }
+}
+
+/**
+ * The interface `TypeSystem` defines the behavior of an object representing
+ * the type system.  This provides a common location to put methods that act on
+ * types but may need access to more global data structures, and it paves the
+ * way for a possible future where we may wish to make the type system
+ * pluggable.
+ */
+abstract class TypeSystem {
+  /**
+   * Return the [TypeProvider] associated with this [TypeSystem].
+   */
+  TypeProvider get typeProvider;
+
+  /**
+   * Compute the least upper bound of two types.
+   */
+  DartType getLeastUpperBound(DartType type1, DartType type2);
+
+  /**
+   * Return `true` if the [leftType] is a subtype of the [rightType] (that is,
+   * if leftType <: rightType).
+   */
+  bool isSubtypeOf(DartType leftType, DartType rightType);
+}
+
+/**
+ * Implementation of [TypeSystem] using the rules in the Dart specification.
+ */
+class TypeSystemImpl implements TypeSystem {
+  @override
+  final TypeProvider typeProvider;
+
+  TypeSystemImpl(this.typeProvider);
+
+  @override
+  DartType getLeastUpperBound(DartType type1, DartType type2) {
+    // The least upper bound relation is reflexive.
+    if (identical(type1, type2)) {
+      return type1;
+    }
+    // The least upper bound of dynamic and any type T is dynamic.
+    if (type1.isDynamic) {
+      return type1;
+    }
+    if (type2.isDynamic) {
+      return type2;
+    }
+    // The least upper bound of void and any type T != dynamic is void.
+    if (type1.isVoid) {
+      return type1;
+    }
+    if (type2.isVoid) {
+      return type2;
+    }
+    // The least upper bound of bottom and any type T is T.
+    if (type1.isBottom) {
+      return type2;
+    }
+    if (type2.isBottom) {
+      return type1;
+    }
+    // Let U be a type variable with upper bound B.  The least upper bound of U
+    // and a type T is the least upper bound of B and T.
+    while (type1 is TypeParameterType) {
+      // TODO(paulberry): is this correct in the complex of F-bounded
+      // polymorphism?
+      DartType bound = (type1 as TypeParameterType).element.bound;
+      if (bound == null) {
+        bound = typeProvider.objectType;
+      }
+      type1 = bound;
+    }
+    while (type2 is TypeParameterType) {
+      // TODO(paulberry): is this correct in the context of F-bounded
+      // polymorphism?
+      DartType bound = (type2 as TypeParameterType).element.bound;
+      if (bound == null) {
+        bound = typeProvider.objectType;
+      }
+      type2 = bound;
+    }
+    // The least upper bound of a function type and an interface type T is the
+    // least upper bound of Function and T.
+    if (type1 is FunctionType && type2 is InterfaceType) {
+      type1 = typeProvider.functionType;
+    }
+    if (type2 is FunctionType && type1 is InterfaceType) {
+      type2 = typeProvider.functionType;
+    }
+
+    // At this point type1 and type2 should both either be interface types or
+    // function types.
+    if (type1 is InterfaceType && type2 is InterfaceType) {
+      InterfaceType result =
+          InterfaceTypeImpl.computeLeastUpperBound(type1, type2);
+      if (result == null) {
+        return typeProvider.dynamicType;
+      }
+      return result;
+    } else if (type1 is FunctionType && type2 is FunctionType) {
+      FunctionType result =
+          FunctionTypeImpl.computeLeastUpperBound(type1, type2);
+      if (result == null) {
+        return typeProvider.functionType;
+      }
+      return result;
+    } else {
+      // Should never happen.  As a defensive measure, return the dynamic type.
+      assert(false);
+      return typeProvider.dynamicType;
+    }
+  }
+
+  @override
+  bool isSubtypeOf(DartType leftType, DartType rightType) {
+    return leftType.isSubtypeOf(rightType);
+  }
+}
+
+/**
+ * Instances of the class [UnusedLocalElementsVerifier] traverse an element
+ * structure looking for cases of [HintCode.UNUSED_ELEMENT],
+ * [HintCode.UNUSED_FIELD], [HintCode.UNUSED_LOCAL_VARIABLE], etc.
+ */
+class UnusedLocalElementsVerifier extends RecursiveElementVisitor {
+  /**
+   * The error listener to which errors will be reported.
+   */
+  final AnalysisErrorListener _errorListener;
+
+  /**
+   * The elements know to be used.
+   */
+  final UsedLocalElements _usedElements;
+
+  /**
+   * Create a new instance of the [UnusedLocalElementsVerifier].
+   */
+  UnusedLocalElementsVerifier(this._errorListener, this._usedElements);
+
+  @override
+  visitClassElement(ClassElement element) {
+    if (!_isUsedElement(element)) {
+      _reportErrorForElement(HintCode.UNUSED_ELEMENT, element,
+          [element.kind.displayName, element.displayName]);
+    }
+    super.visitClassElement(element);
+  }
+
+  @override
+  visitFieldElement(FieldElement element) {
+    if (!_isReadMember(element)) {
+      _reportErrorForElement(
+          HintCode.UNUSED_FIELD, element, [element.displayName]);
+    }
+    super.visitFieldElement(element);
+  }
+
+  @override
+  visitFunctionElement(FunctionElement element) {
+    if (!_isUsedElement(element)) {
+      _reportErrorForElement(HintCode.UNUSED_ELEMENT, element,
+          [element.kind.displayName, element.displayName]);
+    }
+    super.visitFunctionElement(element);
+  }
+
+  @override
+  visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
+    if (!_isUsedElement(element)) {
+      _reportErrorForElement(HintCode.UNUSED_ELEMENT, element,
+          [element.kind.displayName, element.displayName]);
+    }
+    super.visitFunctionTypeAliasElement(element);
+  }
+
+  @override
+  visitLocalVariableElement(LocalVariableElement element) {
+    if (!_isUsedElement(element) && !_isNamedUnderscore(element)) {
+      HintCode errorCode;
+      if (_usedElements.isCatchException(element)) {
+        errorCode = HintCode.UNUSED_CATCH_CLAUSE;
+      } else if (_usedElements.isCatchStackTrace(element)) {
+        errorCode = HintCode.UNUSED_CATCH_STACK;
+      } else {
+        errorCode = HintCode.UNUSED_LOCAL_VARIABLE;
+      }
+      _reportErrorForElement(errorCode, element, [element.displayName]);
+    }
+  }
+
+  @override
+  visitMethodElement(MethodElement element) {
+    if (!_isUsedMember(element)) {
+      _reportErrorForElement(HintCode.UNUSED_ELEMENT, element,
+          [element.kind.displayName, element.displayName]);
+    }
+    super.visitMethodElement(element);
+  }
+
+  @override
+  visitPropertyAccessorElement(PropertyAccessorElement element) {
+    if (!_isUsedMember(element)) {
+      _reportErrorForElement(HintCode.UNUSED_ELEMENT, element,
+          [element.kind.displayName, element.displayName]);
+    }
+    super.visitPropertyAccessorElement(element);
+  }
+
+  bool _isNamedUnderscore(LocalVariableElement element) {
+    String name = element.name;
+    if (name != null) {
+      for (int index = name.length - 1; index >= 0; --index) {
+        if (name.codeUnitAt(index) != 0x5F) {
+          // 0x5F => '_'
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+
+  bool _isReadMember(Element element) {
+    if (element.isPublic) {
+      return true;
+    }
+    if (element.isSynthetic) {
+      return true;
+    }
+    return _usedElements.readMembers.contains(element.displayName);
+  }
+
+  bool _isUsedElement(Element element) {
+    if (element.isSynthetic) {
+      return true;
+    }
+    if (element is LocalVariableElement ||
+        element is FunctionElement && !element.isStatic) {
+      // local variable or function
+    } else {
+      if (element.isPublic) {
+        return true;
+      }
+    }
+    return _usedElements.elements.contains(element);
+  }
+
+  bool _isUsedMember(Element element) {
+    if (element.isPublic) {
+      return true;
+    }
+    if (element.isSynthetic) {
+      return true;
+    }
+    if (_usedElements.members.contains(element.displayName)) {
+      return true;
+    }
+    return _usedElements.elements.contains(element);
+  }
+
+  void _reportErrorForElement(
+      ErrorCode errorCode, Element element, List<Object> arguments) {
+    if (element != null) {
+      _errorListener.onError(new AnalysisError(
+          element.source,
+          element.nameOffset,
+          element.displayName.length,
+          errorCode,
+          arguments));
+    }
+  }
+}
+
+/**
+ * A container with information about used imports prefixes and used imported
+ * elements.
+ */
+class UsedImportedElements {
+  /**
+   * The set of referenced [PrefixElement]s.
+   */
+  final Set<PrefixElement> prefixes = new HashSet<PrefixElement>();
+
+  /**
+   * The set of referenced top-level [Element]s.
+   */
+  final Set<Element> elements = new HashSet<Element>();
+}
+
+/**
+ * A container with sets of used [Element]s.
+ * All these elements are defined in a single compilation unit or a library.
+ */
+class UsedLocalElements {
+  /**
+   * Resolved, locally defined elements that are used or potentially can be
+   * used.
+   */
+  final HashSet<Element> elements = new HashSet<Element>();
+
+  /**
+   * [LocalVariableElement]s that represent exceptions in [CatchClause]s.
+   */
+  final HashSet<LocalVariableElement> catchExceptionElements =
+      new HashSet<LocalVariableElement>();
+
+  /**
+   * [LocalVariableElement]s that represent stack traces in [CatchClause]s.
+   */
+  final HashSet<LocalVariableElement> catchStackTraceElements =
+      new HashSet<LocalVariableElement>();
+
+  /**
+   * Names of resolved or unresolved class members that are referenced in the
+   * library.
+   */
+  final HashSet<String> members = new HashSet<String>();
+
+  /**
+   * Names of resolved or unresolved class members that are read in the
+   * library.
+   */
+  final HashSet<String> readMembers = new HashSet<String>();
+
+  UsedLocalElements();
+
+  factory UsedLocalElements.merge(List<UsedLocalElements> parts) {
+    UsedLocalElements result = new UsedLocalElements();
+    for (UsedLocalElements part in parts) {
+      result.elements.addAll(part.elements);
+      result.catchExceptionElements.addAll(part.catchExceptionElements);
+      result.catchStackTraceElements.addAll(part.catchStackTraceElements);
+      result.members.addAll(part.members);
+      result.readMembers.addAll(part.readMembers);
+    }
+    return result;
+  }
+
+  void addCatchException(LocalVariableElement element) {
+    if (element != null) {
+      catchExceptionElements.add(element);
+    }
+  }
+
+  void addCatchStackTrace(LocalVariableElement element) {
+    if (element != null) {
+      catchStackTraceElements.add(element);
+    }
+  }
+
+  void addElement(Element element) {
+    if (element != null) {
+      elements.add(element);
+    }
+  }
+
+  bool isCatchException(LocalVariableElement element) {
+    return catchExceptionElements.contains(element);
+  }
+
+  bool isCatchStackTrace(LocalVariableElement element) {
+    return catchStackTraceElements.contains(element);
+  }
+}
+
+/**
+ * Instances of the class `VariableResolverVisitor` are used to resolve
+ * [SimpleIdentifier]s to local variables and formal parameters.
+ */
+class VariableResolverVisitor extends ScopedVisitor {
+  /**
+   * The method or function that we are currently visiting, or `null` if we are not inside a
+   * method or function.
+   */
+  ExecutableElement _enclosingFunction;
+
+  /**
+   * Initialize a newly created visitor to resolve the nodes in an AST node.
+   *
+   * [definingLibrary] is the element for the library containing the node being
+   * visited.
+   * [source] is the source representing the compilation unit containing the
+   * node being visited
+   * [typeProvider] is the object used to access the types from the core
+   * library.
+   * [errorListener] is the error listener that will be informed of any errors
+   * that are found during resolution.
+   * [nameScope] is the scope used to resolve identifiers in the node that will
+   * first be visited.  If `null` or unspecified, a new [LibraryScope] will be
+   * created based on [definingLibrary] and [typeProvider].
+   */
+  VariableResolverVisitor(LibraryElement definingLibrary, Source source,
+      TypeProvider typeProvider, AnalysisErrorListener errorListener,
+      {Scope nameScope})
+      : super(definingLibrary, source, typeProvider, errorListener,
+            nameScope: nameScope);
+
+  /**
+   * Initialize a newly created visitor to resolve the nodes in a compilation unit.
+   *
+   * @param library the library containing the compilation unit being resolved
+   * @param source the source representing the compilation unit being visited
+   * @param typeProvider the object used to access the types from the core library
+   *
+   * Deprecated.  Please use unnamed constructor instead.
+   */
+  @deprecated
+  VariableResolverVisitor.con1(
+      Library library, Source source, TypeProvider typeProvider)
+      : this(
+            library.libraryElement, source, typeProvider, library.errorListener,
+            nameScope: library.libraryScope);
+
+  @override
+  Object visitExportDirective(ExportDirective node) => null;
+
+  @override
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    ExecutableElement outerFunction = _enclosingFunction;
+    try {
+      _enclosingFunction = node.element;
+      return super.visitFunctionDeclaration(node);
+    } finally {
+      _enclosingFunction = outerFunction;
+    }
+  }
+
+  @override
+  Object visitFunctionExpression(FunctionExpression node) {
+    if (node.parent is! FunctionDeclaration) {
+      ExecutableElement outerFunction = _enclosingFunction;
+      try {
+        _enclosingFunction = node.element;
+        return super.visitFunctionExpression(node);
+      } finally {
+        _enclosingFunction = outerFunction;
+      }
+    } else {
+      return super.visitFunctionExpression(node);
+    }
+  }
+
+  @override
+  Object visitImportDirective(ImportDirective node) => null;
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement outerFunction = _enclosingFunction;
+    try {
+      _enclosingFunction = node.element;
+      return super.visitMethodDeclaration(node);
+    } finally {
+      _enclosingFunction = outerFunction;
+    }
+  }
+
+  @override
+  Object visitSimpleIdentifier(SimpleIdentifier node) {
+    // Ignore if already resolved - declaration or type.
+    if (node.staticElement != null) {
+      return null;
+    }
+    // Ignore if qualified.
+    AstNode parent = node.parent;
+    if (parent is PrefixedIdentifier && identical(parent.identifier, node)) {
+      return null;
+    }
+    if (parent is PropertyAccess && identical(parent.propertyName, node)) {
+      return null;
+    }
+    if (parent is MethodInvocation &&
+        identical(parent.methodName, node) &&
+        parent.realTarget != null) {
+      return null;
+    }
+    if (parent is ConstructorName) {
+      return null;
+    }
+    if (parent is Label) {
+      return null;
+    }
+    // Prepare VariableElement.
+    Element element = nameScope.lookup(node, definingLibrary);
+    if (element is! VariableElement) {
+      return null;
+    }
+    // Must be local or parameter.
+    ElementKind kind = element.kind;
+    if (kind == ElementKind.LOCAL_VARIABLE) {
+      node.staticElement = element;
+      LocalVariableElementImpl variableImpl =
+          element as LocalVariableElementImpl;
+      if (node.inSetterContext()) {
+        variableImpl.markPotentiallyMutatedInScope();
+        if (element.enclosingElement != _enclosingFunction) {
+          variableImpl.markPotentiallyMutatedInClosure();
+        }
+      }
+    } else if (kind == ElementKind.PARAMETER) {
+      node.staticElement = element;
+      if (node.inSetterContext()) {
+        ParameterElementImpl parameterImpl = element as ParameterElementImpl;
+        parameterImpl.markPotentiallyMutatedInScope();
+        // If we are in some closure, check if it is not the same as where
+        // variable is declared.
+        if (_enclosingFunction != null &&
+            (element.enclosingElement != _enclosingFunction)) {
+          parameterImpl.markPotentiallyMutatedInClosure();
+        }
+      }
+    }
+    return null;
+  }
+}
+
+class _ConstantVerifier_validateInitializerExpression extends ConstantVisitor {
+  final ConstantVerifier verifier;
+
+  List<ParameterElement> parameterElements;
+
+  _ConstantVerifier_validateInitializerExpression(
+      TypeProvider typeProvider,
+      ErrorReporter errorReporter,
+      this.verifier,
+      this.parameterElements,
+      DeclaredVariables declaredVariables)
+      : super(new ConstantEvaluationEngine(typeProvider, declaredVariables),
+            errorReporter);
+
+  @override
+  DartObjectImpl visitSimpleIdentifier(SimpleIdentifier node) {
+    Element element = node.staticElement;
+    for (ParameterElement parameterElement in parameterElements) {
+      if (identical(parameterElement, element) && parameterElement != null) {
+        DartType type = parameterElement.type;
+        if (type != null) {
+          if (type.isDynamic) {
+            return new DartObjectImpl(
+                verifier._typeProvider.objectType, DynamicState.DYNAMIC_STATE);
+          } else if (type.isSubtypeOf(verifier._boolType)) {
+            return new DartObjectImpl(
+                verifier._typeProvider.boolType, BoolState.UNKNOWN_VALUE);
+          } else if (type.isSubtypeOf(verifier._typeProvider.doubleType)) {
+            return new DartObjectImpl(
+                verifier._typeProvider.doubleType, DoubleState.UNKNOWN_VALUE);
+          } else if (type.isSubtypeOf(verifier._intType)) {
+            return new DartObjectImpl(
+                verifier._typeProvider.intType, IntState.UNKNOWN_VALUE);
+          } else if (type.isSubtypeOf(verifier._numType)) {
+            return new DartObjectImpl(
+                verifier._typeProvider.numType, NumState.UNKNOWN_VALUE);
+          } else if (type.isSubtypeOf(verifier._stringType)) {
+            return new DartObjectImpl(
+                verifier._typeProvider.stringType, StringState.UNKNOWN_VALUE);
+          }
+          //
+          // We don't test for other types of objects (such as List, Map,
+          // Function or Type) because there are no operations allowed on such
+          // types other than '==' and '!=', which means that we don't need to
+          // know the type when there is no specific data about the state of
+          // such objects.
+          //
+        }
+        return new DartObjectImpl(
+            type is InterfaceType ? type : verifier._typeProvider.objectType,
+            GenericState.UNKNOWN_VALUE);
+      }
+    }
+    return super.visitSimpleIdentifier(node);
+  }
+}
+
+class _ElementBuilder_visitClassDeclaration extends UnifyingAstVisitor<Object> {
+  final ElementBuilder builder;
+
+  List<ClassMember> nonFields;
+
+  _ElementBuilder_visitClassDeclaration(this.builder, this.nonFields) : super();
+
+  @override
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    nonFields.add(node);
+    return null;
+  }
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    nonFields.add(node);
+    return null;
+  }
+
+  @override
+  Object visitNode(AstNode node) => node.accept(builder);
+}
+
+class _ResolverVisitor_isVariableAccessedInClosure
+    extends RecursiveAstVisitor<Object> {
+  final Element variable;
+
+  bool result = false;
+
+  bool _inClosure = false;
+
+  _ResolverVisitor_isVariableAccessedInClosure(this.variable);
+
+  @override
+  Object visitFunctionExpression(FunctionExpression node) {
+    bool inClosure = this._inClosure;
+    try {
+      this._inClosure = true;
+      return super.visitFunctionExpression(node);
+    } finally {
+      this._inClosure = inClosure;
+    }
+  }
+
+  @override
+  Object visitSimpleIdentifier(SimpleIdentifier node) {
+    if (result) {
+      return null;
+    }
+    if (_inClosure && identical(node.staticElement, variable)) {
+      result = true;
+    }
+    return null;
+  }
+}
+
+class _ResolverVisitor_isVariablePotentiallyMutatedIn
+    extends RecursiveAstVisitor<Object> {
+  final Element variable;
+
+  bool result = false;
+
+  _ResolverVisitor_isVariablePotentiallyMutatedIn(this.variable);
+
+  @override
+  Object visitSimpleIdentifier(SimpleIdentifier node) {
+    if (result) {
+      return null;
+    }
+    if (identical(node.staticElement, variable)) {
+      if (node.inSetterContext()) {
+        result = true;
+      }
+    }
+    return null;
+  }
+}
+
+class _TypeResolverVisitor_visitClassMembersInScope
+    extends UnifyingAstVisitor<Object> {
+  final TypeResolverVisitor TypeResolverVisitor_this;
+
+  List<ClassMember> nonFields;
+
+  _TypeResolverVisitor_visitClassMembersInScope(
+      this.TypeResolverVisitor_this, this.nonFields)
+      : super();
+
+  @override
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    nonFields.add(node);
+    return null;
+  }
+
+  @override
+  Object visitExtendsClause(ExtendsClause node) => null;
+
+  @override
+  Object visitImplementsClause(ImplementsClause node) => null;
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    nonFields.add(node);
+    return null;
+  }
+
+  @override
+  Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
+
+  @override
+  Object visitWithClause(WithClause node) => null;
+}