Move dart2js from sdk/lib/_internal/compiler to pkg/compiler

sdk/lib/_internal/compiler/implementation/resolution/members.dart

Index: sdk/lib/_internal/compiler/implementation/resolution/members.dart
diff --git a/sdk/lib/_internal/compiler/implementation/resolution/members.dart b/sdk/lib/_internal/compiler/implementation/resolution/members.dart
deleted file mode 100644
index 937d308a4afbc195fa6be76d78d86e5b2586eeb7..0000000000000000000000000000000000000000
--- a/sdk/lib/_internal/compiler/implementation/resolution/members.dart
+++ /dev/null
@@ -1,5054 +0,0 @@
-// Copyright (c) 2012, 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.
-
-part of resolution;
-
-abstract class TreeElements {
-  AnalyzableElement get analyzedElement;
-  Iterable<Node> get superUses;
-
-  /// Iterables of the dependencies that this [TreeElement] records of
-  /// [analyzedElement].
-  Iterable<Element> get allElements;
-  void forEachConstantNode(f(Node n, ConstantExpression c));
-
-  /// A set of additional dependencies.  See [registerDependency] below.
-  Iterable<Element> get otherDependencies;
-
-  Element operator[](Node node);
-
-  // TODO(johnniwinther): Investigate whether [Node] could be a [Send].
-  Selector getSelector(Node node);
-  Selector getGetterSelectorInComplexSendSet(SendSet node);
-  Selector getOperatorSelectorInComplexSendSet(SendSet node);
-  DartType getType(Node node);
-  void setSelector(Node node, Selector selector);
-  void setGetterSelectorInComplexSendSet(SendSet node, Selector selector);
-  void setOperatorSelectorInComplexSendSet(SendSet node, Selector selector);
-
-  /// Returns the for-in loop variable for [node].
-  Element getForInVariable(ForIn node);
-  Selector getIteratorSelector(ForIn node);
-  Selector getMoveNextSelector(ForIn node);
-  Selector getCurrentSelector(ForIn node);
-  void setIteratorSelector(ForIn node, Selector selector);
-  void setMoveNextSelector(ForIn node, Selector selector);
-  void setCurrentSelector(ForIn node, Selector selector);
-  void setConstant(Node node, ConstantExpression constant);
-  ConstantExpression getConstant(Node node);
-  bool isAssert(Send send);
-
-  /// Returns the [FunctionElement] defined by [node].
-  FunctionElement getFunctionDefinition(FunctionExpression node);
-
-  /// Returns target constructor for the redirecting factory body [node].
-  ConstructorElement getRedirectingTargetConstructor(
-      RedirectingFactoryBody node);
-
-  /**
-   * Returns [:true:] if [node] is a type literal.
-   *
-   * Resolution marks this by setting the type on the node to be the
-   * type that the literal refers to.
-   */
-  bool isTypeLiteral(Send node);
-
-  /// Returns the type that the type literal [node] refers to.
-  DartType getTypeLiteralType(Send node);
-
-  /// Register additional dependencies required by [analyzedElement].
-  /// For example, elements that are used by a backend.
-  void registerDependency(Element element);
-
-  /// Returns a list of nodes that potentially mutate [element] anywhere in its
-  /// scope.
-  List<Node> getPotentialMutations(VariableElement element);
-
-  /// Returns a list of nodes that potentially mutate [element] in [node].
-  List<Node> getPotentialMutationsIn(Node node, VariableElement element);
-
-  /// Returns a list of nodes that potentially mutate [element] in a closure.
-  List<Node> getPotentialMutationsInClosure(VariableElement element);
-
-  /// Returns a list of nodes that access [element] within a closure in [node].
-  List<Node> getAccessesByClosureIn(Node node, VariableElement element);
-
-  /// Returns the jump target defined by [node].
-  JumpTarget getTargetDefinition(Node node);
-
-  /// Returns the jump target of the [node].
-  JumpTarget getTargetOf(GotoStatement node);
-
-  /// Returns the label defined by [node].
-  LabelDefinition getLabelDefinition(Label node);
-
-  /// Returns the label that [node] targets.
-  LabelDefinition getTargetLabel(GotoStatement node);
-}
-
-class TreeElementMapping implements TreeElements {
-  final AnalyzableElement analyzedElement;
-  Map<Spannable, Selector> _selectors;
-  Map<Node, DartType> _types;
-  Setlet<Node> _superUses;
-  Setlet<Element> _otherDependencies;
-  Map<Node, ConstantExpression> _constants;
-  Map<VariableElement, List<Node>> _potentiallyMutated;
-  Map<Node, Map<VariableElement, List<Node>>> _potentiallyMutatedIn;
-  Map<VariableElement, List<Node>> _potentiallyMutatedInClosure;
-  Map<Node, Map<VariableElement, List<Node>>> _accessedByClosureIn;
-  Setlet<Element> _elements;
-  Setlet<Send> _asserts;
-
-  /// Map from nodes to the targets they define.
-  Map<Node, JumpTarget> _definedTargets;
-
-  /// Map from goto statements to their targets.
-  Map<GotoStatement, JumpTarget> _usedTargets;
-
-  /// Map from labels to their label definition.
-  Map<Label, LabelDefinition> _definedLabels;
-
-  /// Map from labeled goto statements to the labels they target.
-  Map<GotoStatement, LabelDefinition> _targetLabels;
-
-  final int hashCode = ++_hashCodeCounter;
-  static int _hashCodeCounter = 0;
-
-  TreeElementMapping(this.analyzedElement);
-
-  operator []=(Node node, Element element) {
-    assert(invariant(node, () {
-      FunctionExpression functionExpression = node.asFunctionExpression();
-      if (functionExpression != null) {
-        return !functionExpression.modifiers.isExternal;
-      }
-      return true;
-    }));
-    // TODO(johnniwinther): Simplify this invariant to use only declarations in
-    // [TreeElements].
-    assert(invariant(node, () {
-      if (!element.isErroneous && analyzedElement != null && element.isPatch) {
-        return analyzedElement.implementationLibrary.isPatch;
-      }
-      return true;
-    }));
-    // TODO(ahe): Investigate why the invariant below doesn't hold.
-    // assert(invariant(node,
-    //                  getTreeElement(node) == element ||
-    //                  getTreeElement(node) == null,
-    //                  message: '${getTreeElement(node)}; $element'));
-
-    if (_elements == null) {
-      _elements = new Setlet<Element>();
-    }
-    _elements.add(element);
-    setTreeElement(node, element);
-  }
-
-  operator [](Node node) => getTreeElement(node);
-
-  void setType(Node node, DartType type) {
-    if (_types == null) {
-      _types = new Maplet<Node, DartType>();
-    }
-    _types[node] = type;
-  }
-
-  DartType getType(Node node) => _types != null ? _types[node] : null;
-
-  Iterable<Node> get superUses {
-    return _superUses != null ? _superUses : const <Node>[];
-  }
-
-  void addSuperUse(Node node) {
-    if (_superUses == null) {
-      _superUses = new Setlet<Node>();
-    }
-    _superUses.add(node);
-  }
-
-  Selector _getSelector(Spannable node) {
-    return _selectors != null ? _selectors[node] : null;
-  }
-
-  void _setSelector(Spannable node, Selector selector) {
-    if (_selectors == null) {
-      _selectors = new Maplet<Spannable, Selector>();
-    }
-    _selectors[node] = selector;
-  }
-
-  void setSelector(Node node, Selector selector) {
-    _setSelector(node, selector);
-  }
-
-  Selector getSelector(Node node) => _getSelector(node);
-
-  int getSelectorCount() => _selectors == null ? 0 : _selectors.length;
-
-  void setGetterSelectorInComplexSendSet(SendSet node, Selector selector) {
-    _setSelector(node.selector, selector);
-  }
-
-  Selector getGetterSelectorInComplexSendSet(SendSet node) {
-    return _getSelector(node.selector);
-  }
-
-  void setOperatorSelectorInComplexSendSet(SendSet node, Selector selector) {
-    _setSelector(node.assignmentOperator, selector);
-  }
-
-  Selector getOperatorSelectorInComplexSendSet(SendSet node) {
-    return _getSelector(node.assignmentOperator);
-  }
-
-  // The following methods set selectors on the "for in" node. Since
-  // we're using three selectors, we need to use children of the node,
-  // and we arbitrarily choose which ones.
-
-  void setIteratorSelector(ForIn node, Selector selector) {
-    _setSelector(node, selector);
-  }
-
-  Selector getIteratorSelector(ForIn node) {
-    return _getSelector(node);
-  }
-
-  void setMoveNextSelector(ForIn node, Selector selector) {
-    _setSelector(node.forToken, selector);
-  }
-
-  Selector getMoveNextSelector(ForIn node) {
-    return _getSelector(node.forToken);
-  }
-
-  void setCurrentSelector(ForIn node, Selector selector) {
-    _setSelector(node.inToken, selector);
-  }
-
-  Selector getCurrentSelector(ForIn node) {
-    return _getSelector(node.inToken);
-  }
-
-  Element getForInVariable(ForIn node) {
-    return this[node];
-  }
-
-  void setConstant(Node node, ConstantExpression constant) {
-    if (_constants == null) {
-      _constants = new Maplet<Node, ConstantExpression>();
-    }
-    _constants[node] = constant;
-  }
-
-  ConstantExpression getConstant(Node node) {
-    return _constants != null ? _constants[node] : null;
-  }
-
-  bool isTypeLiteral(Send node) {
-    return getType(node) != null;
-  }
-
-  DartType getTypeLiteralType(Send node) {
-    return getType(node);
-  }
-
-  void registerDependency(Element element) {
-    if (element == null) return;
-    if (_otherDependencies == null) {
-      _otherDependencies = new Setlet<Element>();
-    }
-    _otherDependencies.add(element.implementation);
-  }
-
-  Iterable<Element> get otherDependencies {
-    return _otherDependencies != null ? _otherDependencies : const <Element>[];
-  }
-
-  List<Node> getPotentialMutations(VariableElement element) {
-    if (_potentiallyMutated == null) return const <Node>[];
-    List<Node> mutations = _potentiallyMutated[element];
-    if (mutations == null) return const <Node>[];
-    return mutations;
-  }
-
-  void registerPotentialMutation(VariableElement element, Node mutationNode) {
-    if (_potentiallyMutated == null) {
-      _potentiallyMutated = new Maplet<VariableElement, List<Node>>();
-    }
-    _potentiallyMutated.putIfAbsent(element, () => <Node>[]).add(mutationNode);
-  }
-
-  List<Node> getPotentialMutationsIn(Node node, VariableElement element) {
-    if (_potentiallyMutatedIn == null) return const <Node>[];
-    Map<VariableElement, List<Node>> mutationsIn = _potentiallyMutatedIn[node];
-    if (mutationsIn == null) return const <Node>[];
-    List<Node> mutations = mutationsIn[element];
-    if (mutations == null) return const <Node>[];
-    return mutations;
-  }
-
-  void registerPotentialMutationIn(Node contextNode, VariableElement element,
-                                    Node mutationNode) {
-    if (_potentiallyMutatedIn == null) {
-      _potentiallyMutatedIn =
-          new Maplet<Node, Map<VariableElement, List<Node>>>();
-    }
-    Map<VariableElement, List<Node>> mutationMap =
-        _potentiallyMutatedIn.putIfAbsent(contextNode,
-          () => new Maplet<VariableElement, List<Node>>());
-    mutationMap.putIfAbsent(element, () => <Node>[]).add(mutationNode);
-  }
-
-  List<Node> getPotentialMutationsInClosure(VariableElement element) {
-    if (_potentiallyMutatedInClosure == null) return const <Node>[];
-    List<Node> mutations = _potentiallyMutatedInClosure[element];
-    if (mutations == null) return const <Node>[];
-    return mutations;
-  }
-
-  void registerPotentialMutationInClosure(VariableElement element,
-                                          Node mutationNode) {
-    if (_potentiallyMutatedInClosure == null) {
-      _potentiallyMutatedInClosure = new Maplet<VariableElement, List<Node>>();
-    }
-    _potentiallyMutatedInClosure.putIfAbsent(
-        element, () => <Node>[]).add(mutationNode);
-  }
-
-  List<Node> getAccessesByClosureIn(Node node, VariableElement element) {
-    if (_accessedByClosureIn == null) return const <Node>[];
-    Map<VariableElement, List<Node>> accessesIn = _accessedByClosureIn[node];
-    if (accessesIn == null) return const <Node>[];
-    List<Node> accesses = accessesIn[element];
-    if (accesses == null) return const <Node>[];
-    return accesses;
-  }
-
-  void setAccessedByClosureIn(Node contextNode, VariableElement element,
-                              Node accessNode) {
-    if (_accessedByClosureIn == null) {
-      _accessedByClosureIn = new Map<Node, Map<VariableElement, List<Node>>>();
-    }
-    Map<VariableElement, List<Node>> accessMap =
-        _accessedByClosureIn.putIfAbsent(contextNode,
-          () => new Maplet<VariableElement, List<Node>>());
-    accessMap.putIfAbsent(element, () => <Node>[]).add(accessNode);
-  }
-
-  String toString() => 'TreeElementMapping($analyzedElement)';
-
-  Iterable<Element> get allElements {
-    return _elements != null ? _elements : const <Element>[];
-  }
-
-  void forEachConstantNode(f(Node n, ConstantExpression c)) {
-    if (_constants != null) {
-      _constants.forEach(f);
-    }
-  }
-
-  void setAssert(Send node) {
-    if (_asserts == null) {
-      _asserts = new Setlet<Send>();
-    }
-    _asserts.add(node);
-  }
-
-  bool isAssert(Send node) {
-    return _asserts != null && _asserts.contains(node);
-  }
-
-  FunctionElement getFunctionDefinition(FunctionExpression node) {
-    return this[node];
-  }
-
-  ConstructorElement getRedirectingTargetConstructor(
-      RedirectingFactoryBody node) {
-    return this[node];
-  }
-
-  void defineTarget(Node node, JumpTarget target) {
-    if (_definedTargets == null) {
-      _definedTargets = new Maplet<Node, JumpTarget>();
-    }
-    _definedTargets[node] = target;
-  }
-
-  void undefineTarget(Node node) {
-    if (_definedTargets != null) {
-      _definedTargets.remove(node);
-      if (_definedTargets.isEmpty) {
-        _definedTargets = null;
-      }
-    }
-  }
-
-  JumpTarget getTargetDefinition(Node node) {
-    return _definedTargets != null ? _definedTargets[node] : null;
-  }
-
-  void registerTargetOf(GotoStatement node, JumpTarget target) {
-    if (_usedTargets == null) {
-      _usedTargets = new Maplet<GotoStatement, JumpTarget>();
-    }
-    _usedTargets[node] = target;
-  }
-
-  JumpTarget getTargetOf(GotoStatement node) {
-    return _usedTargets != null ? _usedTargets[node] : null;
-  }
-
-  void defineLabel(Label label, LabelDefinition target) {
-    if (_definedLabels == null) {
-      _definedLabels = new Maplet<Label, LabelDefinition>();
-    }
-    _definedLabels[label] = target;
-  }
-
-  void undefineLabel(Label label) {
-    if (_definedLabels != null) {
-      _definedLabels.remove(label);
-      if (_definedLabels.isEmpty) {
-        _definedLabels = null;
-      }
-    }
-  }
-
-  LabelDefinition getLabelDefinition(Label label) {
-    return _definedLabels != null ? _definedLabels[label] : null;
-  }
-
-  void registerTargetLabel(GotoStatement node, LabelDefinition label) {
-    assert(node.target != null);
-    if (_targetLabels == null) {
-      _targetLabels = new Maplet<GotoStatement, LabelDefinition>();
-    }
-    _targetLabels[node] = label;
-  }
-
-  LabelDefinition getTargetLabel(GotoStatement node) {
-    assert(node.target != null);
-    return _targetLabels != null ? _targetLabels[node] : null;
-  }
-}
-
-class ResolverTask extends CompilerTask {
-  final ConstantCompiler constantCompiler;
-
-  ResolverTask(Compiler compiler, this.constantCompiler) : super(compiler);
-
-  String get name => 'Resolver';
-
-  TreeElements resolve(Element element) {
-    return measure(() {
-      if (Elements.isErroneousElement(element)) return null;
-
-      processMetadata([result]) {
-        for (MetadataAnnotation metadata in element.metadata) {
-          metadata.ensureResolved(compiler);
-        }
-        return result;
-      }
-
-      ElementKind kind = element.kind;
-      if (identical(kind, ElementKind.GENERATIVE_CONSTRUCTOR) ||
-          identical(kind, ElementKind.FUNCTION) ||
-          identical(kind, ElementKind.GETTER) ||
-          identical(kind, ElementKind.SETTER)) {
-        return processMetadata(resolveMethodElement(element));
-      }
-
-      if (identical(kind, ElementKind.FIELD)) {
-        return processMetadata(resolveField(element));
-      }
-      if (element.isClass) {
-        ClassElement cls = element;
-        cls.ensureResolved(compiler);
-        return processMetadata();
-      } else if (element.isTypedef) {
-        TypedefElement typdef = element;
-        return processMetadata(resolveTypedef(typdef));
-      }
-
-      compiler.unimplemented(element, "resolve($element)");
-    });
-  }
-
-  void resolveRedirectingConstructor(InitializerResolver resolver,
-                                     Node node,
-                                     FunctionElement constructor,
-                                     FunctionElement redirection) {
-    assert(invariant(node, constructor.isImplementation,
-        message: 'Redirecting constructors must be resolved on implementation '
-                 'elements.'));
-    Setlet<FunctionElement> seen = new Setlet<FunctionElement>();
-    seen.add(constructor);
-    while (redirection != null) {
-      // Ensure that we follow redirections through implementation elements.
-      redirection = redirection.implementation;
-      if (seen.contains(redirection)) {
-        resolver.visitor.error(node, MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE);
-        return;
-      }
-      seen.add(redirection);
-      redirection = resolver.visitor.resolveConstructorRedirection(redirection);
-    }
-  }
-
-  void checkMatchingPatchParameters(FunctionElement origin,
-                                    Link<Element> originParameters,
-                                    Link<Element> patchParameters) {
-    while (!originParameters.isEmpty) {
-      ParameterElementX originParameter = originParameters.head;
-      ParameterElementX patchParameter = patchParameters.head;
-      // TODO(johnniwinther): Remove the conditional patching when we never
-      // resolve the same method twice.
-      if (!originParameter.isPatched) {
-        originParameter.applyPatch(patchParameter);
-      } else {
-        assert(invariant(origin, originParameter.patch == patchParameter,
-               message: "Inconsistent repatch of $originParameter."));
-      }
-      DartType originParameterType = originParameter.computeType(compiler);
-      DartType patchParameterType = patchParameter.computeType(compiler);
-      if (originParameterType != patchParameterType) {
-        compiler.reportError(
-            originParameter.parseNode(compiler),
-            MessageKind.PATCH_PARAMETER_TYPE_MISMATCH,
-            {'methodName': origin.name,
-             'parameterName': originParameter.name,
-             'originParameterType': originParameterType,
-             'patchParameterType': patchParameterType});
-        compiler.reportInfo(patchParameter,
-            MessageKind.PATCH_POINT_TO_PARAMETER,
-            {'parameterName': patchParameter.name});
-      } else {
-        // Hack: Use unparser to test parameter equality. This only works
-        // because we are restricting patch uses and the approach cannot be used
-        // elsewhere.
-
-        // The node contains the type, so there is a potential overlap.
-        // Therefore we only check the text if the types are identical.
-        String originParameterText =
-            originParameter.parseNode(compiler).toString();
-        String patchParameterText =
-            patchParameter.parseNode(compiler).toString();
-        if (originParameterText != patchParameterText
-            // We special case the list constructor because of the
-            // optional parameter.
-            && origin != compiler.unnamedListConstructor) {
-          compiler.reportError(
-              originParameter.parseNode(compiler),
-              MessageKind.PATCH_PARAMETER_MISMATCH,
-              {'methodName': origin.name,
-               'originParameter': originParameterText,
-               'patchParameter': patchParameterText});
-          compiler.reportInfo(patchParameter,
-              MessageKind.PATCH_POINT_TO_PARAMETER,
-              {'parameterName': patchParameter.name});
-        }
-      }
-
-      originParameters = originParameters.tail;
-      patchParameters = patchParameters.tail;
-    }
-  }
-
-  void checkMatchingPatchSignatures(FunctionElement origin,
-                                    FunctionElement patch) {
-    // TODO(johnniwinther): Show both origin and patch locations on errors.
-    FunctionExpression originTree = origin.node;
-    FunctionSignature originSignature = origin.functionSignature;
-    FunctionExpression patchTree = patch.node;
-    FunctionSignature patchSignature = patch.functionSignature;
-
-    if (originSignature.type.returnType != patchSignature.type.returnType) {
-      compiler.withCurrentElement(patch, () {
-        Node errorNode =
-            patchTree.returnType != null ? patchTree.returnType : patchTree;
-        error(errorNode, MessageKind.PATCH_RETURN_TYPE_MISMATCH,
-              {'methodName': origin.name,
-               'originReturnType': originSignature.type.returnType,
-               'patchReturnType': patchSignature.type.returnType});
-      });
-    }
-    if (originSignature.requiredParameterCount !=
-        patchSignature.requiredParameterCount) {
-      compiler.withCurrentElement(patch, () {
-        error(patchTree,
-              MessageKind.PATCH_REQUIRED_PARAMETER_COUNT_MISMATCH,
-              {'methodName': origin.name,
-               'originParameterCount': originSignature.requiredParameterCount,
-               'patchParameterCount': patchSignature.requiredParameterCount});
-      });
-    } else {
-      checkMatchingPatchParameters(origin,
-                                   originSignature.requiredParameters,
-                                   patchSignature.requiredParameters);
-    }
-    if (originSignature.optionalParameterCount != 0 &&
-        patchSignature.optionalParameterCount != 0) {
-      if (originSignature.optionalParametersAreNamed !=
-          patchSignature.optionalParametersAreNamed) {
-        compiler.withCurrentElement(patch, () {
-          error(patchTree,
-                MessageKind.PATCH_OPTIONAL_PARAMETER_NAMED_MISMATCH,
-                {'methodName': origin.name});
-        });
-      }
-    }
-    if (originSignature.optionalParameterCount !=
-        patchSignature.optionalParameterCount) {
-      compiler.withCurrentElement(patch, () {
-        error(patchTree,
-              MessageKind.PATCH_OPTIONAL_PARAMETER_COUNT_MISMATCH,
-              {'methodName': origin.name,
-               'originParameterCount': originSignature.optionalParameterCount,
-               'patchParameterCount': patchSignature.optionalParameterCount});
-      });
-    } else {
-      checkMatchingPatchParameters(origin,
-                                   originSignature.optionalParameters,
-                                   patchSignature.optionalParameters);
-    }
-  }
-
-  static void processAsyncMarker(Compiler compiler,
-                                 BaseFunctionElementX element) {
-    FunctionExpression functionExpression = element.node;
-    AsyncModifier asyncModifier = functionExpression.asyncModifier;
-    if (asyncModifier != null) {
-      if (!compiler.enableAsyncAwait) {
-        compiler.reportError(asyncModifier,
-            MessageKind.EXPERIMENTAL_ASYNC_AWAIT,
-            {'modifier': element.asyncMarker});
-      } else if (!compiler.analyzeOnly) {
-        compiler.reportError(asyncModifier,
-            MessageKind.EXPERIMENTAL_ASYNC_AWAIT,
-            {'modifier': element.asyncMarker});
-      }
-
-      if (asyncModifier.isAsynchronous) {
-        element.asyncMarker = asyncModifier.isYielding
-            ? AsyncMarker.ASYNC_STAR : AsyncMarker.ASYNC;
-      } else {
-        element.asyncMarker = AsyncMarker.SYNC_STAR;
-      }
-      if (element.isAbstract) {
-        compiler.reportError(asyncModifier,
-            MessageKind.ASYNC_MODIFIER_ON_ABSTRACT_METHOD,
-            {'modifier': element.asyncMarker});
-      } else if (element.isConstructor) {
-        compiler.reportError(asyncModifier,
-            MessageKind.ASYNC_MODIFIER_ON_CONSTRUCTOR,
-            {'modifier': element.asyncMarker});
-      } else if (functionExpression.body.asReturn() != null &&
-                 element.asyncMarker.isYielding) {
-        compiler.reportError(asyncModifier,
-            MessageKind.YIELDING_MODIFIER_ON_ARROW_BODY,
-            {'modifier': element.asyncMarker});
-      }
-    }
-  }
-
-  TreeElements resolveMethodElement(FunctionElementX element) {
-    assert(invariant(element, element.isDeclaration));
-    return compiler.withCurrentElement(element, () {
-      bool isConstructor =
-          identical(element.kind, ElementKind.GENERATIVE_CONSTRUCTOR);
-      if (compiler.enqueuer.resolution.hasBeenResolved(element)) {
-        // TODO(karlklose): Remove the check for [isConstructor]. [elememts]
-        // should never be non-null, not even for constructors.
-        assert(invariant(element, element.isConstructor,
-            message: 'Non-constructor element $element '
-                     'has already been analyzed.'));
-        return element.resolvedAst.elements;
-      }
-      if (element.isSynthesized) {
-        if (isConstructor) {
-          ResolutionRegistry registry =
-              new ResolutionRegistry(compiler, element);
-          ConstructorElement constructor = element.asFunctionElement();
-          ConstructorElement target = constructor.definingConstructor;
-          // Ensure the signature of the synthesized element is
-          // resolved. This is the only place where the resolver is
-          // seeing this element.
-          element.computeSignature(compiler);
-          if (!target.isErroneous) {
-            registry.registerStaticUse(target);
-            registry.registerImplicitSuperCall(target);
-          }
-          return registry.mapping;
-        } else {
-          assert(element.isDeferredLoaderGetter);
-          return _ensureTreeElements(element);
-        }
-      }
-      element.parseNode(compiler);
-      element.computeType(compiler);
-      processAsyncMarker(compiler, element);
-      if (element.isPatched) {
-        FunctionElementX patch = element.patch;
-        compiler.withCurrentElement(patch, () {
-          patch.parseNode(compiler);
-          patch.computeType(compiler);
-        });
-        checkMatchingPatchSignatures(element, patch);
-        element = patch;
-        processAsyncMarker(compiler, element);
-      }
-      return compiler.withCurrentElement(element, () {
-        FunctionExpression tree = element.node;
-        if (tree.modifiers.isExternal) {
-          error(tree, MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
-          return null;
-        }
-        if (isConstructor || element.isFactoryConstructor) {
-          if (tree.returnType != null) {
-            error(tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
-          }
-          if (element.modifiers.isConst &&
-              tree.hasBody() &&
-              !tree.isRedirectingFactory) {
-            compiler.reportError(tree, MessageKind.CONST_CONSTRUCTOR_HAS_BODY);
-          }
-        }
-
-        ResolverVisitor visitor = visitorFor(element);
-        ResolutionRegistry registry = visitor.registry;
-        registry.defineFunction(tree, element);
-        visitor.setupFunction(tree, element);
-
-        if (isConstructor && !element.isForwardingConstructor) {
-          // Even if there is no initializer list we still have to do the
-          // resolution in case there is an implicit super constructor call.
-          InitializerResolver resolver = new InitializerResolver(visitor);
-          FunctionElement redirection =
-              resolver.resolveInitializers(element, tree);
-          if (redirection != null) {
-            resolveRedirectingConstructor(resolver, tree, element, redirection);
-          }
-        } else if (element.isForwardingConstructor) {
-          // Initializers will be checked on the original constructor.
-        } else if (tree.initializers != null) {
-          error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
-        }
-
-        if (!compiler.analyzeSignaturesOnly || tree.isRedirectingFactory) {
-          // We need to analyze the redirecting factory bodies to ensure that
-          // we can analyze compile-time constants.
-          visitor.visit(tree.body);
-        }
-
-        // Get the resolution tree and check that the resolved
-        // function doesn't use 'super' if it is mixed into another
-        // class. This is the part of the 'super' mixin check that
-        // happens when a function is resolved after the mixin
-        // application has been performed.
-        TreeElements resolutionTree = registry.mapping;
-        ClassElement enclosingClass = element.enclosingClass;
-        if (enclosingClass != null) {
-          // TODO(johnniwinther): Find another way to obtain mixin uses.
-          Iterable<MixinApplicationElement> mixinUses =
-              compiler.world.allMixinUsesOf(enclosingClass);
-          ClassElement mixin = enclosingClass;
-          for (MixinApplicationElement mixinApplication in mixinUses) {
-            checkMixinSuperUses(resolutionTree, mixinApplication, mixin);
-          }
-        }
-        return resolutionTree;
-      });
-    });
-  }
-
-  /// Creates a [ResolverVisitor] for resolving an AST in context of [element].
-  /// If [useEnclosingScope] is `true` then the initial scope of the visitor
-  /// does not include inner scope of [element].
-  ///
-  /// This method should only be used by this library (or tests of
-  /// this library).
-  ResolverVisitor visitorFor(Element element, {bool useEnclosingScope: false}) {
-    return new ResolverVisitor(compiler, element,
-        new ResolutionRegistry(compiler, element),
-        useEnclosingScope: useEnclosingScope);
-  }
-
-  TreeElements resolveField(FieldElementX element) {
-    VariableDefinitions tree = element.parseNode(compiler);
-    if(element.modifiers.isStatic && element.isTopLevel) {
-      error(element.modifiers.getStatic(),
-            MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
-    }
-    ResolverVisitor visitor = visitorFor(element);
-    ResolutionRegistry registry = visitor.registry;
-    // TODO(johnniwinther): Maybe remove this when placeholderCollector migrates
-    // to the backend ast.
-    registry.defineElement(tree.definitions.nodes.head, element);
-    // TODO(johnniwinther): Share the resolved type between all variables
-    // declared in the same declaration.
-    if (tree.type != null) {
-      element.variables.type = visitor.resolveTypeAnnotation(tree.type);
-    } else {
-      element.variables.type = const DynamicType();
-    }
-
-    Expression initializer = element.initializer;
-    Modifiers modifiers = element.modifiers;
-    if (initializer != null) {
-      // TODO(johnniwinther): Avoid analyzing initializers if
-      // [Compiler.analyzeSignaturesOnly] is set.
-      visitor.visit(initializer);
-    } else if (modifiers.isConst) {
-      compiler.reportError(element, MessageKind.CONST_WITHOUT_INITIALIZER);
-    } else if (modifiers.isFinal && !element.isInstanceMember) {
-      compiler.reportError(element, MessageKind.FINAL_WITHOUT_INITIALIZER);
-    } else {
-      registry.registerInstantiatedClass(compiler.nullClass);
-    }
-
-    if (Elements.isStaticOrTopLevelField(element)) {
-      visitor.addDeferredAction(element, () {
-        if (element.modifiers.isConst) {
-          constantCompiler.compileConstant(element);
-        } else {
-          constantCompiler.compileVariable(element);
-        }
-      });
-      if (initializer != null) {
-        if (!element.modifiers.isConst) {
-          // TODO(johnniwinther): Determine the const-ness eagerly to avoid
-          // unnecessary registrations.
-          registry.registerLazyField();
-        }
-      }
-    }
-
-    // Perform various checks as side effect of "computing" the type.
-    element.computeType(compiler);
-
-    return registry.mapping;
-  }
-
-  DartType resolveTypeAnnotation(Element element, TypeAnnotation annotation) {
-    DartType type = resolveReturnType(element, annotation);
-    if (type.isVoid) {
-      error(annotation, MessageKind.VOID_NOT_ALLOWED);
-    }
-    return type;
-  }
-
-  DartType resolveReturnType(Element element, TypeAnnotation annotation) {
-    if (annotation == null) return const DynamicType();
-    DartType result = visitorFor(element).resolveTypeAnnotation(annotation);
-    if (result == null) {
-      // TODO(karklose): warning.
-      return const DynamicType();
-    }
-    return result;
-  }
-
-  void resolveRedirectionChain(ConstructorElementX constructor,
-                               Spannable node) {
-    ConstructorElementX target = constructor;
-    InterfaceType targetType;
-    List<Element> seen = new List<Element>();
-    // Follow the chain of redirections and check for cycles.
-    while (target.isRedirectingFactory) {
-      if (target.internalEffectiveTarget != null) {
-        // We found a constructor that already has been processed.
-        targetType = target.effectiveTargetType;
-        assert(invariant(target, targetType != null,
-            message: 'Redirection target type has not been computed for '
-                     '$target'));
-        target = target.internalEffectiveTarget;
-        break;
-      }
-
-      Element nextTarget = target.immediateRedirectionTarget;
-      if (seen.contains(nextTarget)) {
-        error(node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
-        break;
-      }
-      seen.add(target);
-      target = nextTarget;
-    }
-
-    if (targetType == null) {
-      assert(!target.isRedirectingFactory);
-      targetType = target.enclosingClass.thisType;
-    }
-
-    // [target] is now the actual target of the redirections.  Run through
-    // the constructors again and set their [redirectionTarget], so that we
-    // do not have to run the loop for these constructors again. Furthermore,
-    // compute [redirectionTargetType] for each factory by computing the
-    // substitution of the target type with respect to the factory type.
-    while (!seen.isEmpty) {
-      ConstructorElementX factory = seen.removeLast();
-
-      // [factory] must already be analyzed but the [TreeElements] might not
-      // have been stored in the enqueuer cache yet.
-      // TODO(johnniwinther): Store [TreeElements] in the cache before
-      // resolution of the element.
-      TreeElements treeElements = factory.treeElements;
-      assert(invariant(node, treeElements != null,
-          message: 'No TreeElements cached for $factory.'));
-      FunctionExpression functionNode = factory.parseNode(compiler);
-      RedirectingFactoryBody redirectionNode = functionNode.body;
-      InterfaceType factoryType = treeElements.getType(redirectionNode);
-
-      targetType = targetType.substByContext(factoryType);
-      factory.effectiveTarget = target;
-      factory.effectiveTargetType = targetType;
-    }
-  }
-
-  /**
-   * Load and resolve the supertypes of [cls].
-   *
-   * Warning: do not call this method directly. It should only be
-   * called by [resolveClass] and [ClassSupertypeResolver].
-   */
-  void loadSupertypes(BaseClassElementX cls, Spannable from) {
-    compiler.withCurrentElement(cls, () => measure(() {
-      if (cls.supertypeLoadState == STATE_DONE) return;
-      if (cls.supertypeLoadState == STATE_STARTED) {
-        compiler.reportError(from, MessageKind.CYCLIC_CLASS_HIERARCHY,
-                                 {'className': cls.name});
-        cls.supertypeLoadState = STATE_DONE;
-        cls.hasIncompleteHierarchy = true;
-        cls.allSupertypesAndSelf =
-            compiler.objectClass.allSupertypesAndSelf.extendClass(
-                cls.computeType(compiler));
-        cls.supertype = cls.allSupertypes.head;
-        assert(invariant(from, cls.supertype != null,
-            message: 'Missing supertype on cyclic class $cls.'));
-        cls.interfaces = const Link<DartType>();
-        return;
-      }
-      cls.supertypeLoadState = STATE_STARTED;
-      compiler.withCurrentElement(cls, () {
-        // TODO(ahe): Cache the node in cls.
-        cls.parseNode(compiler).accept(
-            new ClassSupertypeResolver(compiler, cls));
-        if (cls.supertypeLoadState != STATE_DONE) {
-          cls.supertypeLoadState = STATE_DONE;
-        }
-      });
-    }));
-  }
-
-  // TODO(johnniwinther): Remove this queue when resolution has been split into
-  // syntax and semantic resolution.
-  TypeDeclarationElement currentlyResolvedTypeDeclaration;
-  Queue<ClassElement> pendingClassesToBeResolved = new Queue<ClassElement>();
-  Queue<ClassElement> pendingClassesToBePostProcessed =
-      new Queue<ClassElement>();
-
-  /// Resolve [element] using [resolveTypeDeclaration].
-  ///
-  /// This methods ensure that class declarations encountered through type
-  /// annotations during the resolution of [element] are resolved after
-  /// [element] has been resolved.
-  // TODO(johnniwinther): Encapsulate this functionality in a
-  // 'TypeDeclarationResolver'.
-  _resolveTypeDeclaration(TypeDeclarationElement element,
-                          resolveTypeDeclaration()) {
-    return compiler.withCurrentElement(element, () {
-      return measure(() {
-        TypeDeclarationElement previousResolvedTypeDeclaration =
-            currentlyResolvedTypeDeclaration;
-        currentlyResolvedTypeDeclaration = element;
-        var result = resolveTypeDeclaration();
-        if (previousResolvedTypeDeclaration == null) {
-          do {
-            while (!pendingClassesToBeResolved.isEmpty) {
-              pendingClassesToBeResolved.removeFirst().ensureResolved(compiler);
-            }
-            while (!pendingClassesToBePostProcessed.isEmpty) {
-              _postProcessClassElement(
-                  pendingClassesToBePostProcessed.removeFirst());
-            }
-          } while (!pendingClassesToBeResolved.isEmpty);
-          assert(pendingClassesToBeResolved.isEmpty);
-          assert(pendingClassesToBePostProcessed.isEmpty);
-        }
-        currentlyResolvedTypeDeclaration = previousResolvedTypeDeclaration;
-        return result;
-      });
-    });
-  }
-
-  /**
-   * Resolve the class [element].
-   *
-   * Before calling this method, [element] was constructed by the
-   * scanner and most fields are null or empty. This method fills in
-   * these fields and also ensure that the supertypes of [element] are
-   * resolved.
-   *
-   * Warning: Do not call this method directly. Instead use
-   * [:element.ensureResolved(compiler):].
-   */
-  TreeElements resolveClass(BaseClassElementX element) {
-    return _resolveTypeDeclaration(element, () {
-      // TODO(johnniwinther): Store the mapping in the resolution enqueuer.
-      ResolutionRegistry registry = new ResolutionRegistry(compiler, element);
-      resolveClassInternal(element, registry);
-      return element.treeElements;
-    });
-  }
-
-  void _ensureClassWillBeResolved(ClassElement element) {
-    if (currentlyResolvedTypeDeclaration == null) {
-      element.ensureResolved(compiler);
-    } else {
-      pendingClassesToBeResolved.add(element);
-    }
-  }
-
-  void resolveClassInternal(BaseClassElementX element,
-                            ResolutionRegistry registry) {
-    if (!element.isPatch) {
-      compiler.withCurrentElement(element, () => measure(() {
-        assert(element.resolutionState == STATE_NOT_STARTED);
-        element.resolutionState = STATE_STARTED;
-        Node tree = element.parseNode(compiler);
-        loadSupertypes(element, tree);
-
-        ClassResolverVisitor visitor =
-            new ClassResolverVisitor(compiler, element, registry);
-        visitor.visit(tree);
-        element.resolutionState = STATE_DONE;
-        compiler.onClassResolved(element);
-        pendingClassesToBePostProcessed.add(element);
-      }));
-      if (element.isPatched) {
-        // Ensure handling patch after origin.
-        element.patch.ensureResolved(compiler);
-      }
-    } else { // Handle patch classes:
-      element.resolutionState = STATE_STARTED;
-      // Ensure handling origin before patch.
-      element.origin.ensureResolved(compiler);
-      // Ensure that the type is computed.
-      element.computeType(compiler);
-      // Copy class hierarchy from origin.
-      element.supertype = element.origin.supertype;
-      element.interfaces = element.origin.interfaces;
-      element.allSupertypesAndSelf = element.origin.allSupertypesAndSelf;
-      // Stepwise assignment to ensure invariant.
-      element.supertypeLoadState = STATE_STARTED;
-      element.supertypeLoadState = STATE_DONE;
-      element.resolutionState = STATE_DONE;
-      // TODO(johnniwinther): Check matching type variables and
-      // empty extends/implements clauses.
-    }
-  }
-
-  void _postProcessClassElement(BaseClassElementX element) {
-    for (MetadataAnnotation metadata in element.metadata) {
-      metadata.ensureResolved(compiler);
-      if (!element.isProxy &&
-          metadata.constant.value == compiler.proxyConstant) {
-        element.isProxy = true;
-      }
-    }
-
-    // Force resolution of metadata on non-instance members since they may be
-    // inspected by the backend while emitting. Metadata on instance members is
-    // handled as a result of processing instantiated class members in the
-    // enqueuer.
-    // TODO(ahe): Avoid this eager resolution.
-    element.forEachMember((_, Element member) {
-      if (!member.isInstanceMember) {
-        compiler.withCurrentElement(member, () {
-          for (MetadataAnnotation metadata in member.metadata) {
-            metadata.ensureResolved(compiler);
-          }
-        });
-      }
-    });
-
-    computeClassMember(element, Compiler.CALL_OPERATOR_NAME);
-  }
-
-  void computeClassMembers(ClassElement element) {
-    MembersCreator.computeAllClassMembers(compiler, element);
-  }
-
-  void computeClassMember(ClassElement element, String name) {
-    MembersCreator.computeClassMembersByName(compiler, element, name);
-  }
-
-  void checkClass(ClassElement element) {
-    computeClassMembers(element);
-    if (element.isMixinApplication) {
-      checkMixinApplication(element);
-    } else {
-      checkClassMembers(element);
-    }
-  }
-
-  void checkMixinApplication(MixinApplicationElementX mixinApplication) {
-    Modifiers modifiers = mixinApplication.modifiers;
-    int illegalFlags = modifiers.flags & ~Modifiers.FLAG_ABSTRACT;
-    if (illegalFlags != 0) {
-      Modifiers illegalModifiers = new Modifiers.withFlags(null, illegalFlags);
-      compiler.reportError(
-          modifiers,
-          MessageKind.ILLEGAL_MIXIN_APPLICATION_MODIFIERS,
-          {'modifiers': illegalModifiers});
-    }
-
-    // In case of cyclic mixin applications, the mixin chain will have
-    // been cut. If so, we have already reported the error to the
-    // user so we just return from here.
-    ClassElement mixin = mixinApplication.mixin;
-    if (mixin == null) return;
-
-    // Check that we're not trying to use Object as a mixin.
-    if (mixin.superclass == null) {
-      compiler.reportError(mixinApplication,
-                               MessageKind.ILLEGAL_MIXIN_OBJECT);
-      // Avoid reporting additional errors for the Object class.
-      return;
-    }
-
-    // Check that the mixed in class has Object as its superclass.
-    if (!mixin.superclass.isObject) {
-      compiler.reportError(mixin, MessageKind.ILLEGAL_MIXIN_SUPERCLASS);
-    }
-
-    // Check that the mixed in class doesn't have any constructors and
-    // make sure we aren't mixing in methods that use 'super'.
-    mixin.forEachLocalMember((AstElement member) {
-      if (member.isGenerativeConstructor && !member.isSynthesized) {
-        compiler.reportError(member, MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR);
-      } else {
-        // Get the resolution tree and check that the resolved member
-        // doesn't use 'super'. This is the part of the 'super' mixin
-        // check that happens when a function is resolved before the
-        // mixin application has been performed.
-        // TODO(johnniwinther): Obtain the [TreeElements] for [member]
-        // differently.
-        if (compiler.enqueuer.resolution.hasBeenResolved(member)) {
-          checkMixinSuperUses(
-              member.resolvedAst.elements,
-              mixinApplication,
-              mixin);
-        }
-      }
-    });
-  }
-
-  void checkMixinSuperUses(TreeElements resolutionTree,
-                           MixinApplicationElement mixinApplication,
-                           ClassElement mixin) {
-    // TODO(johnniwinther): Avoid the use of [TreeElements] here.
-    if (resolutionTree == null) return;
-    Iterable<Node> superUses = resolutionTree.superUses;
-    if (superUses.isEmpty) return;
-    compiler.reportError(mixinApplication,
-                         MessageKind.ILLEGAL_MIXIN_WITH_SUPER,
-                         {'className': mixin.name});
-    // Show the user the problematic uses of 'super' in the mixin.
-    for (Node use in superUses) {
-      compiler.reportInfo(
-          use,
-          MessageKind.ILLEGAL_MIXIN_SUPER_USE);
-    }
-  }
-
-  void checkClassMembers(ClassElement cls) {
-    assert(invariant(cls, cls.isDeclaration));
-    if (cls.isObject) return;
-    // TODO(johnniwinther): Should this be done on the implementation element as
-    // well?
-    List<Element> constConstructors = <Element>[];
-    List<Element> nonFinalInstanceFields = <Element>[];
-    cls.forEachMember((holder, member) {
-      compiler.withCurrentElement(member, () {
-        // Perform various checks as side effect of "computing" the type.
-        member.computeType(compiler);
-
-        // Check modifiers.
-        if (member.isFunction && member.modifiers.isFinal) {
-          compiler.reportError(
-              member, MessageKind.ILLEGAL_FINAL_METHOD_MODIFIER);
-        }
-        if (member.isConstructor) {
-          final mismatchedFlagsBits =
-              member.modifiers.flags &
-              (Modifiers.FLAG_STATIC | Modifiers.FLAG_ABSTRACT);
-          if (mismatchedFlagsBits != 0) {
-            final mismatchedFlags =
-                new Modifiers.withFlags(null, mismatchedFlagsBits);
-            compiler.reportError(
-                member,
-                MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS,
-                {'modifiers': mismatchedFlags});
-          }
-          if (member.modifiers.isConst) {
-            constConstructors.add(member);
-          }
-        }
-        if (member.isField) {
-          if (member.modifiers.isConst && !member.modifiers.isStatic) {
-            compiler.reportError(
-                member, MessageKind.ILLEGAL_CONST_FIELD_MODIFIER);
-          }
-          if (!member.modifiers.isStatic && !member.modifiers.isFinal) {
-            nonFinalInstanceFields.add(member);
-          }
-        }
-        checkAbstractField(member);
-        checkUserDefinableOperator(member);
-      });
-    });
-    if (!constConstructors.isEmpty && !nonFinalInstanceFields.isEmpty) {
-      Spannable span = constConstructors.length > 1
-          ? cls : constConstructors[0];
-      compiler.reportError(span,
-          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS,
-          {'className': cls.name});
-      if (constConstructors.length > 1) {
-        for (Element constructor in constConstructors) {
-          compiler.reportInfo(constructor,
-              MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR);
-        }
-      }
-      for (Element field in nonFinalInstanceFields) {
-        compiler.reportInfo(field,
-            MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD);
-      }
-    }
-  }
-
-  void checkAbstractField(Element member) {
-    // Only check for getters. The test can only fail if there is both a setter
-    // and a getter with the same name, and we only need to check each abstract
-    // field once, so we just ignore setters.
-    if (!member.isGetter) return;
-
-    // Find the associated abstract field.
-    ClassElement classElement = member.enclosingClass;
-    Element lookupElement = classElement.lookupLocalMember(member.name);
-    if (lookupElement == null) {
-      compiler.internalError(member,
-          "No abstract field for accessor");
-    } else if (!identical(lookupElement.kind, ElementKind.ABSTRACT_FIELD)) {
-      compiler.internalError(member,
-          "Inaccessible abstract field for accessor");
-    }
-    AbstractFieldElement field = lookupElement;
-
-    FunctionElementX getter = field.getter;
-    if (getter == null) return;
-    FunctionElementX setter = field.setter;
-    if (setter == null) return;
-    int getterFlags = getter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
-    int setterFlags = setter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
-    if (!identical(getterFlags, setterFlags)) {
-      final mismatchedFlags =
-        new Modifiers.withFlags(null, getterFlags ^ setterFlags);
-      compiler.reportError(
-          field.getter,
-          MessageKind.GETTER_MISMATCH,
-          {'modifiers': mismatchedFlags});
-      compiler.reportError(
-          field.setter,
-          MessageKind.SETTER_MISMATCH,
-          {'modifiers': mismatchedFlags});
-    }
-  }
-
-  void checkUserDefinableOperator(Element member) {
-    FunctionElement function = member.asFunctionElement();
-    if (function == null) return;
-    String value = member.name;
-    if (value == null) return;
-    if (!(isUserDefinableOperator(value) || identical(value, 'unary-'))) return;
-
-    bool isMinus = false;
-    int requiredParameterCount;
-    MessageKind messageKind;
-    if (identical(value, 'unary-')) {
-      isMinus = true;
-      messageKind = MessageKind.MINUS_OPERATOR_BAD_ARITY;
-      requiredParameterCount = 0;
-    } else if (isMinusOperator(value)) {
-      isMinus = true;
-      messageKind = MessageKind.MINUS_OPERATOR_BAD_ARITY;
-      requiredParameterCount = 1;
-    } else if (isUnaryOperator(value)) {
-      messageKind = MessageKind.UNARY_OPERATOR_BAD_ARITY;
-      requiredParameterCount = 0;
-    } else if (isBinaryOperator(value)) {
-      messageKind = MessageKind.BINARY_OPERATOR_BAD_ARITY;
-      requiredParameterCount = 1;
-      if (identical(value, '==')) checkOverrideHashCode(member);
-    } else if (isTernaryOperator(value)) {
-      messageKind = MessageKind.TERNARY_OPERATOR_BAD_ARITY;
-      requiredParameterCount = 2;
-    } else {
-      compiler.internalError(function,
-          'Unexpected user defined operator $value');
-    }
-    checkArity(function, requiredParameterCount, messageKind, isMinus);
-  }
-
-  void checkOverrideHashCode(FunctionElement operatorEquals) {
-    if (operatorEquals.isAbstract) return;
-    ClassElement cls = operatorEquals.enclosingClass;
-    Element hashCodeImplementation =
-        cls.lookupLocalMember('hashCode');
-    if (hashCodeImplementation != null) return;
-    compiler.reportHint(
-        operatorEquals, MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE,
-        {'class': cls.name});
-  }
-
-  void checkArity(FunctionElement function,
-                  int requiredParameterCount, MessageKind messageKind,
-                  bool isMinus) {
-    FunctionExpression node = function.node;
-    FunctionSignature signature = function.functionSignature;
-    if (signature.requiredParameterCount != requiredParameterCount) {
-      Node errorNode = node;
-      if (node.parameters != null) {
-        if (isMinus ||
-            signature.requiredParameterCount < requiredParameterCount) {
-          // If there are too few parameters, point to the whole parameter list.
-          // For instance
-          //
-          //     int operator +() {}
-          //                   ^^
-          //
-          //     int operator []=(value) {}
-          //                     ^^^^^^^
-          //
-          // For operator -, always point the whole parameter list, like
-          //
-          //     int operator -(a, b) {}
-          //                   ^^^^^^
-          //
-          // instead of
-          //
-          //     int operator -(a, b) {}
-          //                       ^
-          //
-          // since the correction might not be to remove 'b' but instead to
-          // remove 'a, b'.
-          errorNode = node.parameters;
-        } else {
-          errorNode = node.parameters.nodes.skip(requiredParameterCount).head;
-        }
-      }
-      compiler.reportError(
-          errorNode, messageKind, {'operatorName': function.name});
-    }
-    if (signature.optionalParameterCount != 0) {
-      Node errorNode =
-          node.parameters.nodes.skip(signature.requiredParameterCount).head;
-      if (signature.optionalParametersAreNamed) {
-        compiler.reportError(
-            errorNode,
-            MessageKind.OPERATOR_NAMED_PARAMETERS,
-            {'operatorName': function.name});
-      } else {
-        compiler.reportError(
-            errorNode,
-            MessageKind.OPERATOR_OPTIONAL_PARAMETERS,
-            {'operatorName': function.name});
-      }
-    }
-  }
-
-  reportErrorWithContext(Element errorneousElement,
-                         MessageKind errorMessage,
-                         Element contextElement,
-                         MessageKind contextMessage) {
-    compiler.reportError(
-        errorneousElement,
-        errorMessage,
-        {'memberName': contextElement.name,
-         'className': contextElement.enclosingClass.name});
-    compiler.reportInfo(contextElement, contextMessage);
-  }
-
-
-  FunctionSignature resolveSignature(FunctionElementX element) {
-    MessageKind defaultValuesError = null;
-    if (element.isFactoryConstructor) {
-      FunctionExpression body = element.parseNode(compiler);
-      if (body.isRedirectingFactory) {
-        defaultValuesError = MessageKind.REDIRECTING_FACTORY_WITH_DEFAULT;
-      }
-    }
-    return compiler.withCurrentElement(element, () {
-      FunctionExpression node =
-          compiler.parser.measure(() => element.parseNode(compiler));
-      return measure(() => SignatureResolver.analyze(
-          compiler, node.parameters, node.returnType, element,
-          new ResolutionRegistry(compiler, element),
-          defaultValuesError: defaultValuesError,
-          createRealParameters: true));
-    });
-  }
-
-  TreeElements resolveTypedef(TypedefElementX element) {
-    if (element.isResolved) return element.treeElements;
-    compiler.world.allTypedefs.add(element);
-    return _resolveTypeDeclaration(element, () {
-      ResolutionRegistry registry = new ResolutionRegistry(compiler, element);
-      return compiler.withCurrentElement(element, () {
-        return measure(() {
-          assert(element.resolutionState == STATE_NOT_STARTED);
-          element.resolutionState = STATE_STARTED;
-          Typedef node =
-            compiler.parser.measure(() => element.parseNode(compiler));
-          TypedefResolverVisitor visitor =
-            new TypedefResolverVisitor(compiler, element, registry);
-          visitor.visit(node);
-          element.resolutionState = STATE_DONE;
-          return registry.mapping;
-        });
-      });
-    });
-  }
-
-  void resolveMetadataAnnotation(MetadataAnnotationX annotation) {
-    compiler.withCurrentElement(annotation.annotatedElement, () => measure(() {
-      assert(annotation.resolutionState == STATE_NOT_STARTED);
-      annotation.resolutionState = STATE_STARTED;
-
-      Node node = annotation.parseNode(compiler);
-      Element annotatedElement = annotation.annotatedElement;
-      AnalyzableElement context = annotatedElement.analyzableElement;
-      ClassElement classElement = annotatedElement.enclosingClass;
-      if (classElement != null) {
-        // The annotation is resolved in the scope of [classElement].
-        classElement.ensureResolved(compiler);
-      }
-      assert(invariant(node, context != null,
-          message: "No context found for metadata annotation "
-                   "on $annotatedElement."));
-      ResolverVisitor visitor = visitorFor(context, useEnclosingScope: true);
-      ResolutionRegistry registry = visitor.registry;
-      node.accept(visitor);
-      // TODO(johnniwinther): Avoid passing the [TreeElements] to
-      // [compileMetadata].
-      annotation.constant =
-          constantCompiler.compileMetadata(annotation, node, registry.mapping);
-      // TODO(johnniwinther): Register the relation between the annotation
-      // and the annotated element instead. This will allow the backend to
-      // retrieve the backend constant and only register metadata on the
-      // elements for which it is needed. (Issue 17732).
-      registry.registerMetadataConstant(annotation, annotatedElement);
-      annotation.resolutionState = STATE_DONE;
-    }));
-  }
-
-  error(Spannable node, MessageKind kind, [arguments = const {}]) {
-    // TODO(ahe): Make non-fatal.
-    compiler.reportFatalError(node, kind, arguments);
-  }
-
-  Link<MetadataAnnotation> resolveMetadata(Element element,
-                                           VariableDefinitions node) {
-    LinkBuilder<MetadataAnnotation> metadata =
-        new LinkBuilder<MetadataAnnotation>();
-    for (Metadata annotation in node.metadata.nodes) {
-      ParameterMetadataAnnotation metadataAnnotation =
-          new ParameterMetadataAnnotation(annotation);
-      metadataAnnotation.annotatedElement = element;
-      metadata.addLast(metadataAnnotation.ensureResolved(compiler));
-    }
-    return metadata.toLink();
-  }
-}
-
-class InitializerResolver {
-  final ResolverVisitor visitor;
-  final Map<Element, Node> initialized;
-  Link<Node> initializers;
-  bool hasSuper;
-
-  InitializerResolver(this.visitor)
-    : initialized = new Map<Element, Node>(), hasSuper = false;
-
-  ResolutionRegistry get registry => visitor.registry;
-
-  error(Node node, MessageKind kind, [arguments = const {}]) {
-    visitor.error(node, kind, arguments);
-  }
-
-  warning(Node node, MessageKind kind, [arguments = const {}]) {
-    visitor.warning(node, kind, arguments);
-  }
-
-  bool isFieldInitializer(SendSet node) {
-    if (node.selector.asIdentifier() == null) return false;
-    if (node.receiver == null) return true;
-    if (node.receiver.asIdentifier() == null) return false;
-    return node.receiver.asIdentifier().isThis();
-  }
-
-  reportDuplicateInitializerError(Element field, Node init, Node existing) {
-    visitor.compiler.reportError(
-        init,
-        MessageKind.DUPLICATE_INITIALIZER, {'fieldName': field.name});
-    visitor.compiler.reportInfo(
-        existing,
-        MessageKind.ALREADY_INITIALIZED, {'fieldName': field.name});
-  }
-
-  void checkForDuplicateInitializers(FieldElementX field, Node init) {
-    // [field] can be null if it could not be resolved.
-    if (field == null) return;
-    String name = field.name;
-    if (initialized.containsKey(field)) {
-      reportDuplicateInitializerError(field, init, initialized[field]);
-    } else if (field.isFinal) {
-      field.parseNode(visitor.compiler);
-      Expression initializer = field.initializer;
-      if (initializer != null) {
-        reportDuplicateInitializerError(field, init, initializer);
-      }
-    }
-    initialized[field] = init;
-  }
-
-  void resolveFieldInitializer(FunctionElement constructor, SendSet init) {
-    // init is of the form [this.]field = value.
-    final Node selector = init.selector;
-    final String name = selector.asIdentifier().source;
-    // Lookup target field.
-    Element target;
-    if (isFieldInitializer(init)) {
-      target = constructor.enclosingClass.lookupLocalMember(name);
-      if (target == null) {
-        error(selector, MessageKind.CANNOT_RESOLVE, {'name': name});
-      } else if (target.kind != ElementKind.FIELD) {
-        error(selector, MessageKind.NOT_A_FIELD, {'fieldName': name});
-      } else if (!target.isInstanceMember) {
-        error(selector, MessageKind.INIT_STATIC_FIELD, {'fieldName': name});
-      }
-    } else {
-      error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
-    }
-    registry.useElement(init, target);
-    registry.registerStaticUse(target);
-    checkForDuplicateInitializers(target, init);
-    // Resolve initializing value.
-    visitor.visitInStaticContext(init.arguments.head);
-  }
-
-  ClassElement getSuperOrThisLookupTarget(FunctionElement constructor,
-                                          bool isSuperCall,
-                                          Node diagnosticNode) {
-    ClassElement lookupTarget = constructor.enclosingClass;
-    if (isSuperCall) {
-      // Calculate correct lookup target and constructor name.
-      if (identical(lookupTarget, visitor.compiler.objectClass)) {
-        error(diagnosticNode, MessageKind.SUPER_INITIALIZER_IN_OBJECT);
-      } else {
-        return lookupTarget.supertype.element;
-      }
-    }
-    return lookupTarget;
-  }
-
-  Element resolveSuperOrThisForSend(FunctionElement constructor,
-                                    FunctionExpression functionNode,
-                                    Send call) {
-    // Resolve the selector and the arguments.
-    ResolverTask resolver = visitor.compiler.resolver;
-    visitor.inStaticContext(() {
-      visitor.resolveSelector(call, null);
-      visitor.resolveArguments(call.argumentsNode);
-    });
-    Selector selector = registry.getSelector(call);
-    bool isSuperCall = Initializers.isSuperConstructorCall(call);
-
-    ClassElement lookupTarget = getSuperOrThisLookupTarget(constructor,
-                                                           isSuperCall,
-                                                           call);
-    Selector constructorSelector =
-        visitor.getRedirectingThisOrSuperConstructorSelector(call);
-    FunctionElement calledConstructor =
-        lookupTarget.lookupConstructor(constructorSelector);
-
-    final bool isImplicitSuperCall = false;
-    final String className = lookupTarget.name;
-    verifyThatConstructorMatchesCall(constructor,
-                                     calledConstructor,
-                                     selector,
-                                     isImplicitSuperCall,
-                                     call,
-                                     className,
-                                     constructorSelector);
-
-    registry.useElement(call, calledConstructor);
-    registry.registerStaticUse(calledConstructor);
-    return calledConstructor;
-  }
-
-  void resolveImplicitSuperConstructorSend(FunctionElement constructor,
-                                           FunctionExpression functionNode) {
-    // If the class has a super resolve the implicit super call.
-    ClassElement classElement = constructor.enclosingClass;
-    ClassElement superClass = classElement.superclass;
-    if (classElement != visitor.compiler.objectClass) {
-      assert(superClass != null);
-      assert(superClass.resolutionState == STATE_DONE);
-      String constructorName = '';
-      Selector callToMatch = new Selector.call(
-          constructorName,
-          classElement.library,
-          0);
-
-      final bool isSuperCall = true;
-      ClassElement lookupTarget = getSuperOrThisLookupTarget(constructor,
-                                                             isSuperCall,
-                                                             functionNode);
-      Selector constructorSelector = new Selector.callDefaultConstructor(
-          visitor.enclosingElement.library);
-      Element calledConstructor = lookupTarget.lookupConstructor(
-          constructorSelector);
-
-      final String className = lookupTarget.name;
-      final bool isImplicitSuperCall = true;
-      verifyThatConstructorMatchesCall(constructor,
-                                       calledConstructor,
-                                       callToMatch,
-                                       isImplicitSuperCall,
-                                       functionNode,
-                                       className,
-                                       constructorSelector);
-      registry.registerImplicitSuperCall(calledConstructor);
-      registry.registerStaticUse(calledConstructor);
-    }
-  }
-
-  void verifyThatConstructorMatchesCall(
-      FunctionElement caller,
-      FunctionElement lookedupConstructor,
-      Selector call,
-      bool isImplicitSuperCall,
-      Node diagnosticNode,
-      String className,
-      Selector constructorSelector) {
-    if (lookedupConstructor == null
-        || !lookedupConstructor.isGenerativeConstructor) {
-      String fullConstructorName = Elements.constructorNameForDiagnostics(
-              className,
-              constructorSelector.name);
-      MessageKind kind = isImplicitSuperCall
-          ? MessageKind.CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT
-          : MessageKind.CANNOT_RESOLVE_CONSTRUCTOR;
-      visitor.compiler.reportError(
-          diagnosticNode, kind, {'constructorName': fullConstructorName});
-    } else {
-      lookedupConstructor.computeSignature(visitor.compiler);
-      if (!call.applies(lookedupConstructor, visitor.compiler.world)) {
-        MessageKind kind = isImplicitSuperCall
-                           ? MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT
-                           : MessageKind.NO_MATCHING_CONSTRUCTOR;
-        visitor.compiler.reportError(diagnosticNode, kind);
-      } else if (caller.isConst
-                 && !lookedupConstructor.isConst) {
-        visitor.compiler.reportError(
-            diagnosticNode, MessageKind.CONST_CALLS_NON_CONST);
-      }
-    }
-  }
-
-  /**
-   * Resolve all initializers of this constructor. In the case of a redirecting
-   * constructor, the resolved constructor's function element is returned.
-   */
-  FunctionElement resolveInitializers(FunctionElement constructor,
-                                      FunctionExpression functionNode) {
-    // Keep track of all "this.param" parameters specified for constructor so
-    // that we can ensure that fields are initialized only once.
-    FunctionSignature functionParameters = constructor.functionSignature;
-    functionParameters.forEachParameter((ParameterElement element) {
-      if (element.isInitializingFormal) {
-        InitializingFormalElement initializingFormal = element;
-        checkForDuplicateInitializers(initializingFormal.fieldElement,
-                                      element.initializer);
-      }
-    });
-
-    if (functionNode.initializers == null) {
-      initializers = const Link<Node>();
-    } else {
-      initializers = functionNode.initializers.nodes;
-    }
-    FunctionElement result;
-    bool resolvedSuper = false;
-    for (Link<Node> link = initializers; !link.isEmpty; link = link.tail) {
-      if (link.head.asSendSet() != null) {
-        final SendSet init = link.head.asSendSet();
-        resolveFieldInitializer(constructor, init);
-      } else if (link.head.asSend() != null) {
-        final Send call = link.head.asSend();
-        if (call.argumentsNode == null) {
-          error(link.head, MessageKind.INVALID_INITIALIZER);
-          continue;
-        }
-        if (Initializers.isSuperConstructorCall(call)) {
-          if (resolvedSuper) {
-            error(call, MessageKind.DUPLICATE_SUPER_INITIALIZER);
-          }
-          resolveSuperOrThisForSend(constructor, functionNode, call);
-          resolvedSuper = true;
-        } else if (Initializers.isConstructorRedirect(call)) {
-          // Check that there is no body (Language specification 7.5.1).  If the
-          // constructor is also const, we already reported an error in
-          // [resolveMethodElement].
-          if (functionNode.hasBody() && !constructor.isConst) {
-            error(functionNode, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_BODY);
-          }
-          // Check that there are no other initializers.
-          if (!initializers.tail.isEmpty) {
-            error(call, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER);
-          }
-          // Check that there are no field initializing parameters.
-          Compiler compiler = visitor.compiler;
-          FunctionSignature signature = constructor.functionSignature;
-          signature.forEachParameter((ParameterElement parameter) {
-            if (parameter.isInitializingFormal) {
-              Node node = parameter.node;
-              error(node, MessageKind.INITIALIZING_FORMAL_NOT_ALLOWED);
-            }
-          });
-          return resolveSuperOrThisForSend(constructor, functionNode, call);
-        } else {
-          visitor.error(call, MessageKind.CONSTRUCTOR_CALL_EXPECTED);
-          return null;
-        }
-      } else {
-        error(link.head, MessageKind.INVALID_INITIALIZER);
-      }
-    }
-    if (!resolvedSuper) {
-      resolveImplicitSuperConstructorSend(constructor, functionNode);
-    }
-    return null;  // If there was no redirection always return null.
-  }
-}
-
-class CommonResolverVisitor<R> extends Visitor<R> {
-  final Compiler compiler;
-
-  CommonResolverVisitor(Compiler this.compiler);
-
-  R visitNode(Node node) {
-    internalError(node,
-        'internal error: Unhandled node: ${node.getObjectDescription()}');
-    return null;
-  }
-
-  R visitEmptyStatement(Node node) => null;
-
-  /** Convenience method for visiting nodes that may be null. */
-  R visit(Node node) => (node == null) ? null : node.accept(this);
-
-  void error(Spannable node, MessageKind kind, [Map arguments = const {}]) {
-    compiler.reportFatalError(node, kind, arguments);
-  }
-
-  void warning(Spannable node, MessageKind kind, [Map arguments = const {}]) {
-    compiler.reportWarning(node, kind, arguments);
-  }
-
-  void internalError(Spannable node, message) {
-    compiler.internalError(node, message);
-  }
-
-  void addDeferredAction(Element element, DeferredAction action) {
-    compiler.enqueuer.resolution.addDeferredAction(element, action);
-  }
-}
-
-abstract class LabelScope {
-  LabelScope get outer;
-  LabelDefinition lookup(String label);
-}
-
-class LabeledStatementLabelScope implements LabelScope {
-  final LabelScope outer;
-  final Map<String, LabelDefinition> labels;
-  LabeledStatementLabelScope(this.outer, this.labels);
-  LabelDefinition lookup(String labelName) {
-    LabelDefinition label = labels[labelName];
-    if (label != null) return label;
-    return outer.lookup(labelName);
-  }
-}
-
-class SwitchLabelScope implements LabelScope {
-  final LabelScope outer;
-  final Map<String, LabelDefinition> caseLabels;
-
-  SwitchLabelScope(this.outer, this.caseLabels);
-
-  LabelDefinition lookup(String labelName) {
-    LabelDefinition result = caseLabels[labelName];
-    if (result != null) return result;
-    return outer.lookup(labelName);
-  }
-}
-
-class EmptyLabelScope implements LabelScope {
-  const EmptyLabelScope();
-  LabelDefinition lookup(String label) => null;
-  LabelScope get outer {
-    throw 'internal error: empty label scope has no outer';
-  }
-}
-
-class StatementScope {
-  LabelScope labels;
-  Link<JumpTarget> breakTargetStack;
-  Link<JumpTarget> continueTargetStack;
-  // Used to provide different numbers to statements if one is inside the other.
-  // Can be used to make otherwise duplicate labels unique.
-  int nestingLevel = 0;
-
-  StatementScope()
-      : labels = const EmptyLabelScope(),
-        breakTargetStack = const Link<JumpTarget>(),
-        continueTargetStack = const Link<JumpTarget>();
-
-  LabelDefinition lookupLabel(String label) {
-    return labels.lookup(label);
-  }
-
-  JumpTarget currentBreakTarget() =>
-    breakTargetStack.isEmpty ? null : breakTargetStack.head;
-
-  JumpTarget currentContinueTarget() =>
-    continueTargetStack.isEmpty ? null : continueTargetStack.head;
-
-  void enterLabelScope(Map<String, LabelDefinition> elements) {
-    labels = new LabeledStatementLabelScope(labels, elements);
-    nestingLevel++;
-  }
-
-  void exitLabelScope() {
-    nestingLevel--;
-    labels = labels.outer;
-  }
-
-  void enterLoop(JumpTarget element) {
-    breakTargetStack = breakTargetStack.prepend(element);
-    continueTargetStack = continueTargetStack.prepend(element);
-    nestingLevel++;
-  }
-
-  void exitLoop() {
-    nestingLevel--;
-    breakTargetStack = breakTargetStack.tail;
-    continueTargetStack = continueTargetStack.tail;
-  }
-
-  void enterSwitch(JumpTarget breakElement,
-                   Map<String, LabelDefinition> continueElements) {
-    breakTargetStack = breakTargetStack.prepend(breakElement);
-    labels = new SwitchLabelScope(labels, continueElements);
-    nestingLevel++;
-  }
-
-  void exitSwitch() {
-    nestingLevel--;
-    breakTargetStack = breakTargetStack.tail;
-    labels = labels.outer;
-  }
-}
-
-class TypeResolver {
-  final Compiler compiler;
-
-  TypeResolver(this.compiler);
-
-  /// Tries to resolve the type name as an element.
-  Element resolveTypeName(Identifier prefixName,
-                          Identifier typeName,
-                          Scope scope,
-                          {bool deferredIsMalformed: true}) {
-    Element element;
-    bool deferredTypeAnnotation = false;
-    if (prefixName != null) {
-      Element prefixElement =
-          lookupInScope(compiler, prefixName, scope, prefixName.source);
-      if (prefixElement != null && prefixElement.isPrefix) {
-        // The receiver is a prefix. Lookup in the imported members.
-        PrefixElement prefix = prefixElement;
-        element = prefix.lookupLocalMember(typeName.source);
-        // TODO(17260, sigurdm): The test for DartBackend is there because
-        // dart2dart outputs malformed types with prefix.
-        if (element != null &&
-            prefix.isDeferred &&
-            deferredIsMalformed &&
-            compiler.backend is! DartBackend) {
-          element = new ErroneousElementX(MessageKind.DEFERRED_TYPE_ANNOTATION,
-                                          {'node': typeName},
-                                          element.name,
-                                          element);
-        }
-      } else {
-        // The caller of this method will create the ErroneousElement for
-        // the MalformedType.
-        element = null;
-      }
-    } else {
-      String stringValue = typeName.source;
-      element = lookupInScope(compiler, typeName, scope, typeName.source);
-    }
-    return element;
-  }
-
-  DartType resolveTypeAnnotation(MappingVisitor visitor, TypeAnnotation node,
-                                 {bool malformedIsError: false,
-                                  bool deferredIsMalformed: true}) {
-    ResolutionRegistry registry = visitor.registry;
-
-    Identifier typeName;
-    DartType type;
-
-    DartType checkNoTypeArguments(DartType type) {
-      List<DartType> arguments = new List<DartType>();
-      bool hasTypeArgumentMismatch = resolveTypeArguments(
-          visitor, node, const <DartType>[], arguments);
-      if (hasTypeArgumentMismatch) {
-        return new MalformedType(
-            new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
-                {'type': node}, typeName.source, visitor.enclosingElement),
-                type, arguments);
-      }
-      return type;
-    }
-
-    Identifier prefixName;
-    Send send = node.typeName.asSend();
-    if (send != null) {
-      // The type name is of the form [: prefix . identifier :].
-      prefixName = send.receiver.asIdentifier();
-      typeName = send.selector.asIdentifier();
-    } else {
-      typeName = node.typeName.asIdentifier();
-      if (identical(typeName.source, 'void')) {
-        type = const VoidType();
-        checkNoTypeArguments(type);
-        registry.useType(node, type);
-        return type;
-      } else if (identical(typeName.source, 'dynamic')) {
-        type = const DynamicType();
-        checkNoTypeArguments(type);
-        registry.useType(node, type);
-        return type;
-      }
-    }
-
-    Element element = resolveTypeName(prefixName, typeName, visitor.scope,
-                                      deferredIsMalformed: deferredIsMalformed);
-
-    DartType reportFailureAndCreateType(MessageKind messageKind,
-                                        Map messageArguments,
-                                        {DartType userProvidedBadType,
-                                         Element erroneousElement}) {
-      if (malformedIsError) {
-        visitor.error(node, messageKind, messageArguments);
-      } else {
-        registry.registerThrowRuntimeError();
-        visitor.warning(node, messageKind, messageArguments);
-      }
-      if (erroneousElement == null) {
-         erroneousElement = new ErroneousElementX(
-            messageKind, messageArguments, typeName.source,
-            visitor.enclosingElement);
-      }
-      List<DartType> arguments = <DartType>[];
-      resolveTypeArguments(visitor, node, const <DartType>[], arguments);
-      return new MalformedType(erroneousElement,
-              userProvidedBadType, arguments);
-    }
-
-    // Try to construct the type from the element.
-    if (element == null) {
-      type = reportFailureAndCreateType(
-          MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
-    } else if (element.isAmbiguous) {
-      AmbiguousElement ambiguous = element;
-      type = reportFailureAndCreateType(
-          ambiguous.messageKind, ambiguous.messageArguments);
-      ambiguous.diagnose(registry.mapping.analyzedElement, compiler);
-    } else if (element.isErroneous) {
-      ErroneousElement erroneousElement = element;
-      type = reportFailureAndCreateType(
-          erroneousElement.messageKind, erroneousElement.messageArguments,
-          erroneousElement: erroneousElement);
-    } else if (!element.impliesType) {
-      type = reportFailureAndCreateType(
-          MessageKind.NOT_A_TYPE, {'node': node.typeName});
-    } else {
-      bool addTypeVariableBoundsCheck = false;
-      if (element.isClass) {
-        ClassElement cls = element;
-        // TODO(johnniwinther): [_ensureClassWillBeResolved] should imply
-        // [computeType].
-        compiler.resolver._ensureClassWillBeResolved(cls);
-        element.computeType(compiler);
-        List<DartType> arguments = <DartType>[];
-        bool hasTypeArgumentMismatch = resolveTypeArguments(
-            visitor, node, cls.typeVariables, arguments);
-        if (hasTypeArgumentMismatch) {
-          type = new BadInterfaceType(cls.declaration,
-              new InterfaceType.forUserProvidedBadType(cls.declaration,
-                                                       arguments));
-        } else {
-          if (arguments.isEmpty) {
-            type = cls.rawType;
-          } else {
-            type = new InterfaceType(cls.declaration, arguments.toList(growable: false));
-            addTypeVariableBoundsCheck = true;
-          }
-        }
-      } else if (element.isTypedef) {
-        TypedefElement typdef = element;
-        // TODO(johnniwinther): [ensureResolved] should imply [computeType].
-        typdef.ensureResolved(compiler);
-        element.computeType(compiler);
-        List<DartType> arguments = <DartType>[];
-        bool hasTypeArgumentMismatch = resolveTypeArguments(
-            visitor, node, typdef.typeVariables, arguments);
-        if (hasTypeArgumentMismatch) {
-          type = new BadTypedefType(typdef,
-              new TypedefType.forUserProvidedBadType(typdef, arguments));
-        } else {
-          if (arguments.isEmpty) {
-            type = typdef.rawType;
-          } else {
-            type = new TypedefType(typdef, arguments.toList(growable: false));
-            addTypeVariableBoundsCheck = true;
-          }
-        }
-      } else if (element.isTypeVariable) {
-        Element outer =
-            visitor.enclosingElement.outermostEnclosingMemberOrTopLevel;
-        bool isInFactoryConstructor =
-            outer != null && outer.isFactoryConstructor;
-        if (!outer.isClass &&
-            !outer.isTypedef &&
-            !isInFactoryConstructor &&
-            Elements.isInStaticContext(visitor.enclosingElement)) {
-          registry.registerThrowRuntimeError();
-          type = reportFailureAndCreateType(
-              MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
-              {'typeVariableName': node},
-              userProvidedBadType: element.computeType(compiler));
-        } else {
-          type = element.computeType(compiler);
-        }
-        type = checkNoTypeArguments(type);
-      } else {
-        compiler.internalError(node,
-            "Unexpected element kind ${element.kind}.");
-      }
-      if (addTypeVariableBoundsCheck) {
-        registry.registerTypeVariableBoundCheck();
-        visitor.addDeferredAction(
-            visitor.enclosingElement,
-            () => checkTypeVariableBounds(node, type));
-      }
-    }
-    registry.useType(node, type);
-    return type;
-  }
-
-  /// Checks the type arguments of [type] against the type variable bounds.
-  void checkTypeVariableBounds(TypeAnnotation node, GenericType type) {
-    void checkTypeVariableBound(_, DartType typeArgument,
-                                   TypeVariableType typeVariable,
-                                   DartType bound) {
-      if (!compiler.types.isSubtype(typeArgument, bound)) {
-        compiler.reportWarning(node,
-            MessageKind.INVALID_TYPE_VARIABLE_BOUND,
-            {'typeVariable': typeVariable,
-             'bound': bound,
-             'typeArgument': typeArgument,
-             'thisType': type.element.thisType});
-      }
-    };
-
-    compiler.types.checkTypeVariableBounds(type, checkTypeVariableBound);
-  }
-
-  /**
-   * Resolves the type arguments of [node] and adds these to [arguments].
-   *
-   * Returns [: true :] if the number of type arguments did not match the
-   * number of type variables.
-   */
-  bool resolveTypeArguments(MappingVisitor visitor,
-                            TypeAnnotation node,
-                            List<DartType> typeVariables,
-                            List<DartType> arguments) {
-    if (node.typeArguments == null) {
-      return false;
-    }
-    int expectedVariables = typeVariables.length;
-    int index = 0;
-    bool typeArgumentCountMismatch = false;
-    for (Link<Node> typeArguments = node.typeArguments.nodes;
-         !typeArguments.isEmpty;
-         typeArguments = typeArguments.tail, index++) {
-      if (index > expectedVariables - 1) {
-        visitor.warning(
-            typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
-        typeArgumentCountMismatch = true;
-      }
-      DartType argType = resolveTypeAnnotation(visitor, typeArguments.head);
-      // TODO(karlklose): rewrite to not modify [arguments].
-      arguments.add(argType);
-    }
-    if (index < expectedVariables) {
-      visitor.warning(node.typeArguments,
-                      MessageKind.MISSING_TYPE_ARGUMENT);
-      typeArgumentCountMismatch = true;
-    }
-    return typeArgumentCountMismatch;
-  }
-}
-
-/**
- * Common supertype for resolver visitors that record resolutions in a
- * [ResolutionRegistry].
- */
-abstract class MappingVisitor<T> extends CommonResolverVisitor<T> {
-  final ResolutionRegistry registry;
-  final TypeResolver typeResolver;
-  /// The current enclosing element for the visited AST nodes.
-  Element get enclosingElement;
-  /// The current scope of the visitor.
-  Scope get scope;
-
-  MappingVisitor(Compiler compiler, ResolutionRegistry this.registry)
-      : typeResolver = new TypeResolver(compiler),
-        super(compiler);
-
-  AsyncMarker get currentAsyncMarker => AsyncMarker.SYNC;
-
-  /// Add [element] to the current scope and check for duplicate definitions.
-  void addToScope(Element element) {
-    Element existing = scope.add(element);
-    if (existing != element) {
-      reportDuplicateDefinition(element.name, element, existing);
-    }
-  }
-
-  void checkLocalDefinitionName(Node node, Element element) {
-    if (currentAsyncMarker != AsyncMarker.SYNC) {
-      if (element.name == 'yield' ||
-          element.name == 'async' ||
-          element.name == 'await') {
-        compiler.reportError(
-            node, MessageKind.ASYNC_KEYWORD_AS_IDENTIFIER,
-            {'keyword': element.name,
-             'modifier': currentAsyncMarker});
-      }
-    }
-  }
-
-  /// Register [node] as the definition of [element].
-  void defineLocalVariable(Node node, LocalVariableElement element) {
-    invariant(node, element != null);
-    checkLocalDefinitionName(node, element);
-    registry.defineElement(node, element);
-  }
-
-  void reportDuplicateDefinition(String name,
-                                 Spannable definition,
-                                 Spannable existing) {
-    compiler.reportError(definition,
-        MessageKind.DUPLICATE_DEFINITION, {'name': name});
-    compiler.reportInfo(existing,
-        MessageKind.EXISTING_DEFINITION, {'name': name});
-  }
-}
-
-/**
- * Core implementation of resolution.
- *
- * Do not subclass or instantiate this class outside this library
- * except for testing.
- */
-class ResolverVisitor extends MappingVisitor<ResolutionResult> {
-  /**
-   * The current enclosing element for the visited AST nodes.
-   *
-   * This field is updated when nested closures are visited.
-   */
-  Element enclosingElement;
-  bool inInstanceContext;
-  bool inCheckContext;
-  bool inCatchBlock;
-
-  Scope scope;
-  ClassElement currentClass;
-  ExpressionStatement currentExpressionStatement;
-  bool sendIsMemberAccess = false;
-  StatementScope statementScope;
-  int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
-      | ElementCategory.IMPLIES_TYPE;
-
-  /**
-   * Record of argument nodes to JS_INTERCEPTOR_CONSTANT for deferred
-   * processing.
-   */
-  Set<Node> argumentsToJsInterceptorConstant = null;
-
-  /// When visiting the type declaration of the variable in a [ForIn] loop,
-  /// the initializer of the variable is implicit and we should not emit an
-  /// error when verifying that all final variables are initialized.
-  bool allowFinalWithoutInitializer = false;
-
-  /// The nodes for which variable access and mutation must be registered in
-  /// order to determine when the static type of variables types is promoted.
-  Link<Node> promotionScope = const Link<Node>();
-
-  bool isPotentiallyMutableTarget(Element target) {
-    if (target == null) return false;
-    return (target.isVariable || target.isParameter) &&
-      !(target.isFinal || target.isConst);
-  }
-
-  // TODO(ahe): Find a way to share this with runtime implementation.
-  static final RegExp symbolValidationPattern =
-      new RegExp(r'^(?:[a-zA-Z$][a-zA-Z$0-9_]*\.)*(?:[a-zA-Z$][a-zA-Z$0-9_]*=?|'
-                 r'-|'
-                 r'unary-|'
-                 r'\[\]=|'
-                 r'~|'
-                 r'==|'
-                 r'\[\]|'
-                 r'\*|'
-                 r'/|'
-                 r'%|'
-                 r'~/|'
-                 r'\+|'
-                 r'<<|'
-                 r'>>|'
-                 r'>=|'
-                 r'>|'
-                 r'<=|'
-                 r'<|'
-                 r'&|'
-                 r'\^|'
-                 r'\|'
-                 r')$');
-
-  ResolverVisitor(Compiler compiler,
-                  Element element,
-                  ResolutionRegistry registry,
-                  {bool useEnclosingScope: false})
-    : this.enclosingElement = element,
-      // When the element is a field, we are actually resolving its
-      // initial value, which should not have access to instance
-      // fields.
-      inInstanceContext = (element.isInstanceMember && !element.isField)
-          || element.isGenerativeConstructor,
-      this.currentClass = element.isClassMember ? element.enclosingClass
-                                             : null,
-      this.statementScope = new StatementScope(),
-      scope = useEnclosingScope
-          ? Scope.buildEnclosingScope(element) : element.buildScope(),
-      // The type annotations on a typedef do not imply type checks.
-      // TODO(karlklose): clean this up (dartbug.com/8870).
-      inCheckContext = compiler.enableTypeAssertions &&
-          !element.isLibrary &&
-          !element.isTypedef &&
-          !element.enclosingElement.isTypedef,
-      inCatchBlock = false,
-      super(compiler, registry);
-
-  AsyncMarker get currentAsyncMarker {
-    if (enclosingElement is FunctionElement) {
-      FunctionElement function = enclosingElement;
-      return function.asyncMarker;
-    }
-    return AsyncMarker.SYNC;
-  }
-
-  Element reportLookupErrorIfAny(Element result, Node node, String name) {
-    if (!Elements.isUnresolved(result)) {
-      if (!inInstanceContext && result.isInstanceMember) {
-        compiler.reportError(
-            node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': name});
-        return new ErroneousElementX(MessageKind.NO_INSTANCE_AVAILABLE,
-                                     {'name': name},
-                                     name, enclosingElement);
-      } else if (result.isAmbiguous) {
-        AmbiguousElement ambiguous = result;
-        compiler.reportError(
-            node, ambiguous.messageKind, ambiguous.messageArguments);
-        ambiguous.diagnose(enclosingElement, compiler);
-        return new ErroneousElementX(ambiguous.messageKind,
-                                     ambiguous.messageArguments,
-                                     name, enclosingElement);
-      }
-    }
-    return result;
-  }
-
-  // Create, or reuse an already created, target element for a statement.
-  JumpTarget getOrDefineTarget(Node statement) {
-    JumpTarget element = registry.getTargetDefinition(statement);
-    if (element == null) {
-      element = new JumpTargetX(statement,
-                                   statementScope.nestingLevel,
-                                   enclosingElement);
-      registry.defineTarget(statement, element);
-    }
-    return element;
-  }
-
-  doInCheckContext(action()) {
-    bool wasInCheckContext = inCheckContext;
-    inCheckContext = true;
-    var result = action();
-    inCheckContext = wasInCheckContext;
-    return result;
-  }
-
-  inStaticContext(action()) {
-    bool wasInstanceContext = inInstanceContext;
-    inInstanceContext = false;
-    var result = action();
-    inInstanceContext = wasInstanceContext;
-    return result;
-  }
-
-  doInPromotionScope(Node node, action()) {
-    promotionScope = promotionScope.prepend(node);
-    var result = action();
-    promotionScope = promotionScope.tail;
-    return result;
-  }
-
-  visitInStaticContext(Node node) {
-    inStaticContext(() => visit(node));
-  }
-
-  ErroneousElement warnAndCreateErroneousElement(Node node,
-                                                 String name,
-                                                 MessageKind kind,
-                                                 [Map arguments = const {}]) {
-    compiler.reportWarning(node, kind, arguments);
-    return new ErroneousElementX(kind, arguments, name, enclosingElement);
-  }
-
-  ResolutionResult visitIdentifier(Identifier node) {
-    if (node.isThis()) {
-      if (!inInstanceContext) {
-        error(node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
-      }
-      return null;
-    } else if (node.isSuper()) {
-      if (!inInstanceContext) error(node, MessageKind.NO_SUPER_IN_STATIC);
-      if ((ElementCategory.SUPER & allowedCategory) == 0) {
-        error(node, MessageKind.INVALID_USE_OF_SUPER);
-      }
-      return null;
-    } else {
-      String name = node.source;
-      Element element = lookupInScope(compiler, node, scope, name);
-      if (Elements.isUnresolved(element) && name == 'dynamic') {
-        // TODO(johnniwinther): Remove this hack when we can return more complex
-        // objects than [Element] from this method.
-        element = compiler.typeClass;
-        // Set the type to be `dynamic` to mark that this is a type literal.
-        registry.setType(node, const DynamicType());
-      }
-      element = reportLookupErrorIfAny(element, node, node.source);
-      if (element == null) {
-        if (!inInstanceContext) {
-          element = warnAndCreateErroneousElement(
-              node, node.source, MessageKind.CANNOT_RESOLVE,
-              {'name': node});
-          registry.registerThrowNoSuchMethod();
-        }
-      } else if (element.isErroneous) {
-        // Use the erroneous element.
-      } else {
-        if ((element.kind.category & allowedCategory) == 0) {
-          // TODO(ahe): Improve error message. Need UX input.
-          error(node, MessageKind.GENERIC,
-                {'text': "is not an expression $element"});
-        }
-      }
-      if (!Elements.isUnresolved(element) && element.isClass) {
-        ClassElement classElement = element;
-        classElement.ensureResolved(compiler);
-      }
-      return new ElementResult(registry.useElement(node, element));
-    }
-  }
-
-  ResolutionResult visitTypeAnnotation(TypeAnnotation node) {
-    DartType type = resolveTypeAnnotation(node);
-    if (inCheckContext) {
-      registry.registerIsCheck(type);
-    }
-    return new TypeResult(type);
-  }
-
-  bool isNamedConstructor(Send node) => node.receiver != null;
-
-  Selector getRedirectingThisOrSuperConstructorSelector(Send node) {
-    if (isNamedConstructor(node)) {
-      String constructorName = node.selector.asIdentifier().source;
-      return new Selector.callConstructor(
-          constructorName,
-          enclosingElement.library);
-    } else {
-      return new Selector.callDefaultConstructor(
-          enclosingElement.library);
-    }
-  }
-
-  FunctionElement resolveConstructorRedirection(FunctionElementX constructor) {
-    FunctionExpression node = constructor.parseNode(compiler);
-
-    // A synthetic constructor does not have a node.
-    if (node == null) return null;
-    if (node.initializers == null) return null;
-    Link<Node> initializers = node.initializers.nodes;
-    if (!initializers.isEmpty &&
-        Initializers.isConstructorRedirect(initializers.head)) {
-      Selector selector =
-          getRedirectingThisOrSuperConstructorSelector(initializers.head);
-      final ClassElement classElement = constructor.enclosingClass;
-      return classElement.lookupConstructor(selector);
-    }
-    return null;
-  }
-
-  void setupFunction(FunctionExpression node, FunctionElement function) {
-    Element enclosingElement = function.enclosingElement;
-    if (node.modifiers.isStatic &&
-        enclosingElement.kind != ElementKind.CLASS) {
-      compiler.reportError(node, MessageKind.ILLEGAL_STATIC);
-    }
-
-    scope = new MethodScope(scope, function);
-    // Put the parameters in scope.
-    FunctionSignature functionParameters = function.functionSignature;
-    Link<Node> parameterNodes = (node.parameters == null)
-        ? const Link<Node>() : node.parameters.nodes;
-    functionParameters.forEachParameter((ParameterElement element) {
-      // TODO(karlklose): should be a list of [FormalElement]s, but the actual
-      // implementation uses [Element].
-      Link<Element> optionals = functionParameters.optionalParameters;
-      if (!optionals.isEmpty && element == optionals.head) {
-        NodeList nodes = parameterNodes.head;
-        parameterNodes = nodes.nodes;
-      }
-      visit(element.initializer);
-      VariableDefinitions variableDefinitions = parameterNodes.head;
-      Node parameterNode = variableDefinitions.definitions.nodes.head;
-      // Field parameters (this.x) are not visible inside the constructor. The
-      // fields they reference are visible, but must be resolved independently.
-      if (element.isInitializingFormal) {
-        registry.useElement(parameterNode, element);
-      } else {
-        LocalParameterElement parameterElement = element;
-        defineLocalVariable(parameterNode, parameterElement);
-        addToScope(parameterElement);
-      }
-      parameterNodes = parameterNodes.tail;
-    });
-    addDeferredAction(enclosingElement, () {
-      functionParameters.forEachOptionalParameter((Element parameter) {
-        compiler.resolver.constantCompiler.compileConstant(parameter);
-      });
-    });
-    if (inCheckContext) {
-      functionParameters.forEachParameter((ParameterElement element) {
-        registry.registerIsCheck(element.type);
-      });
-    }
-  }
-
-  visitCascade(Cascade node) {
-    visit(node.expression);
-  }
-
-  visitCascadeReceiver(CascadeReceiver node) {
-    visit(node.expression);
-  }
-
-  visitClassNode(ClassNode node) {
-    internalError(node, "shouldn't be called");
-  }
-
-  visitIn(Node node, Scope nestedScope) {
-    Scope oldScope = scope;
-    scope = nestedScope;
-    ResolutionResult result = visit(node);
-    scope = oldScope;
-    return result;
-  }
-
-  /**
-   * Introduces new default targets for break and continue
-   * before visiting the body of the loop
-   */
-  visitLoopBodyIn(Loop loop, Node body, Scope bodyScope) {
-    JumpTarget element = getOrDefineTarget(loop);
-    statementScope.enterLoop(element);
-    visitIn(body, bodyScope);
-    statementScope.exitLoop();
-    if (!element.isTarget) {
-      registry.undefineTarget(loop);
-    }
-  }
-
-  visitBlock(Block node) {
-    visitIn(node.statements, new BlockScope(scope));
-  }
-
-  visitDoWhile(DoWhile node) {
-    visitLoopBodyIn(node, node.body, new BlockScope(scope));
-    visit(node.condition);
-  }
-
-  visitEmptyStatement(EmptyStatement node) { }
-
-  visitExpressionStatement(ExpressionStatement node) {
-    ExpressionStatement oldExpressionStatement = currentExpressionStatement;
-    currentExpressionStatement = node;
-    visit(node.expression);
-    currentExpressionStatement = oldExpressionStatement;
-  }
-
-  visitFor(For node) {
-    Scope blockScope = new BlockScope(scope);
-    visitIn(node.initializer, blockScope);
-    visitIn(node.condition, blockScope);
-    visitIn(node.update, blockScope);
-    visitLoopBodyIn(node, node.body, blockScope);
-  }
-
-  visitFunctionDeclaration(FunctionDeclaration node) {
-    assert(node.function.name != null);
-    visitFunctionExpression(node.function, inFunctionDeclaration: true);
-  }
-
-
-  /// Process a local function declaration or an anonymous function expression.
-  ///
-  /// [inFunctionDeclaration] is `true` when the current node is the immediate
-  /// child of a function declaration.
-  ///
-  /// This is used to distinguish local function declarations from anonymous
-  /// function expressions.
-  visitFunctionExpression(FunctionExpression node,
-                          {bool inFunctionDeclaration: false}) {
-    bool doAddToScope = inFunctionDeclaration;
-    if (!inFunctionDeclaration && node.name != null) {
-      compiler.reportError(
-          node.name,
-          MessageKind.NAMED_FUNCTION_EXPRESSION,
-          {'name': node.name});
-    }
-    visit(node.returnType);
-    String name;
-    if (node.name == null) {
-      name = "";
-    } else {
-      name = node.name.asIdentifier().source;
-    }
-    LocalFunctionElementX function = new LocalFunctionElementX(
-        name, node, ElementKind.FUNCTION, Modifiers.EMPTY,
-        enclosingElement);
-    function.functionSignatureCache =
-        SignatureResolver.analyze(compiler, node.parameters, node.returnType,
-            function, registry, createRealParameters: true);
-    ResolverTask.processAsyncMarker(compiler, function);
-    checkLocalDefinitionName(node, function);
-    registry.defineFunction(node, function);
-    if (doAddToScope) {
-      addToScope(function);
-    }
-    Scope oldScope = scope; // The scope is modified by [setupFunction].
-    setupFunction(node, function);
-
-    Element previousEnclosingElement = enclosingElement;
-    enclosingElement = function;
-    // Run the body in a fresh statement scope.
-    StatementScope oldStatementScope = statementScope;
-    statementScope = new StatementScope();
-    visit(node.body);
-    statementScope = oldStatementScope;
-
-    scope = oldScope;
-    enclosingElement = previousEnclosingElement;
-
-    registry.registerClosure(function);
-    registry.registerInstantiatedClass(compiler.functionClass);
-  }
-
-  visitIf(If node) {
-    doInPromotionScope(node.condition.expression, () => visit(node.condition));
-    doInPromotionScope(node.thenPart,
-        () => visitIn(node.thenPart, new BlockScope(scope)));
-    visitIn(node.elsePart, new BlockScope(scope));
-  }
-
-  ResolutionResult resolveSend(Send node) {
-    Selector selector = resolveSelector(node, null);
-    if (node.isSuperCall) registry.registerSuperUse(node);
-
-    if (node.receiver == null) {
-      // If this send is of the form "assert(expr);", then
-      // this is an assertion.
-      if (selector.isAssert) {
-        if (selector.argumentCount != 1) {
-          error(node.selector,
-                MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
-                {'argumentCount': selector.argumentCount});
-        } else if (selector.namedArgumentCount != 0) {
-          error(node.selector,
-                MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
-                {'argumentCount': selector.namedArgumentCount});
-        }
-        registry.registerAssert(node);
-        return const AssertResult();
-      }
-
-      return node.selector.accept(this);
-    }
-
-    var oldCategory = allowedCategory;
-    allowedCategory |= ElementCategory.PREFIX | ElementCategory.SUPER;
-    ResolutionResult resolvedReceiver = visit(node.receiver);
-    allowedCategory = oldCategory;
-
-    Element target;
-    String name = node.selector.asIdentifier().source;
-    if (identical(name, 'this')) {
-      // TODO(ahe): Why is this using GENERIC?
-      error(node.selector, MessageKind.GENERIC,
-            {'text': "expected an identifier"});
-    } else if (node.isSuperCall) {
-      if (node.isOperator) {
-        if (isUserDefinableOperator(name)) {
-          name = selector.name;
-        } else {
-          error(node.selector, MessageKind.ILLEGAL_SUPER_SEND, {'name': name});
-        }
-      }
-      if (!inInstanceContext) {
-        error(node.receiver, MessageKind.NO_INSTANCE_AVAILABLE, {'name': name});
-        return null;
-      }
-      if (currentClass.supertype == null) {
-        // This is just to guard against internal errors, so no need
-        // for a real error message.
-        error(node.receiver, MessageKind.GENERIC,
-              {'text': "Object has no superclass"});
-      }
-      // TODO(johnniwinther): Ensure correct behavior if currentClass is a
-      // patch.
-      target = currentClass.lookupSuperSelector(selector);
-      // [target] may be null which means invoking noSuchMethod on
-      // super.
-      if (target == null) {
-        target = warnAndCreateErroneousElement(
-            node, name, MessageKind.NO_SUCH_SUPER_MEMBER,
-            {'className': currentClass, 'memberName': name});
-        // We still need to register the invocation, because we might
-        // call [:super.noSuchMethod:] which calls
-        // [JSInvocationMirror._invokeOn].
-        registry.registerDynamicInvocation(selector);
-        registry.registerSuperNoSuchMethod();
-      }
-    } else if (resolvedReceiver == null ||
-               Elements.isUnresolved(resolvedReceiver.element)) {
-      return null;
-    } else if (resolvedReceiver.element.isClass) {
-      ClassElement receiverClass = resolvedReceiver.element;
-      receiverClass.ensureResolved(compiler);
-      if (node.isOperator) {
-        // When the resolved receiver is a class, we can have two cases:
-        //  1) a static send: C.foo, or
-        //  2) an operator send, where the receiver is a class literal: 'C + 1'.
-        // The following code that looks up the selector on the resolved
-        // receiver will treat the second as the invocation of a static operator
-        // if the resolved receiver is not null.
-        return null;
-      }
-      MembersCreator.computeClassMembersByName(
-          compiler, receiverClass.declaration, name);
-      target = receiverClass.lookupLocalMember(name);
-      if (target == null || target.isInstanceMember) {
-        registry.registerThrowNoSuchMethod();
-        // TODO(johnniwinther): With the simplified [TreeElements] invariant,
-        // try to resolve injected elements if [currentClass] is in the patch
-        // library of [receiverClass].
-
-        // TODO(karlklose): this should be reported by the caller of
-        // [resolveSend] to select better warning messages for getters and
-        // setters.
-        MessageKind kind = (target == null)
-            ? MessageKind.MEMBER_NOT_FOUND
-            : MessageKind.MEMBER_NOT_STATIC;
-        return new ElementResult(warnAndCreateErroneousElement(
-            node, name, kind,
-            {'className': receiverClass.name, 'memberName': name}));
-      } else if (isPrivateName(name) &&
-                 target.library != enclosingElement.library) {
-        registry.registerThrowNoSuchMethod();
-        return new ElementResult(warnAndCreateErroneousElement(
-            node, name, MessageKind.PRIVATE_ACCESS,
-            {'libraryName': target.library.getLibraryOrScriptName(),
-             'name': name}));
-      }
-    } else if (resolvedReceiver.element.isPrefix) {
-      PrefixElement prefix = resolvedReceiver.element;
-      target = prefix.lookupLocalMember(name);
-      if (Elements.isUnresolved(target)) {
-        registry.registerThrowNoSuchMethod();
-        return new ElementResult(warnAndCreateErroneousElement(
-            node, name, MessageKind.NO_SUCH_LIBRARY_MEMBER,
-            {'libraryName': prefix.name, 'memberName': name}));
-      } else if (target.isAmbiguous) {
-        registry.registerThrowNoSuchMethod();
-        AmbiguousElement ambiguous = target;
-        target = warnAndCreateErroneousElement(node, name,
-                                               ambiguous.messageKind,
-                                               ambiguous.messageArguments);
-        ambiguous.diagnose(enclosingElement, compiler);
-        return new ElementResult(target);
-      } else if (target.kind == ElementKind.CLASS) {
-        ClassElement classElement = target;
-        classElement.ensureResolved(compiler);
-      }
-    }
-    return new ElementResult(target);
-  }
-
-  static Selector computeSendSelector(Send node,
-                                      LibraryElement library,
-                                      Element element) {
-    // First determine if this is part of an assignment.
-    bool isSet = node.asSendSet() != null;
-
-    if (node.isIndex) {
-      return isSet ? new Selector.indexSet() : new Selector.index();
-    }
-
-    if (node.isOperator) {
-      String source = node.selector.asOperator().source;
-      String string = source;
-      if (identical(string, '!') ||
-          identical(string, '&&') || identical(string, '||') ||
-          identical(string, 'is') || identical(string, 'as') ||
-          identical(string, '?') ||
-          identical(string, '>>>')) {
-        return null;
-      }
-      String op = source;
-      if (!isUserDefinableOperator(source)) {
-        op = Elements.mapToUserOperatorOrNull(source);
-      }
-      if (op == null) {
-        // Unsupported operator. An error has been reported during parsing.
-        return new Selector.call(
-            source, library, node.argumentsNode.slowLength(), []);
-      }
-      return node.arguments.isEmpty
-          ? new Selector.unaryOperator(op)
-          : new Selector.binaryOperator(op);
-    }
-
-    Identifier identifier = node.selector.asIdentifier();
-    if (node.isPropertyAccess) {
-      assert(!isSet);
-      return new Selector.getter(identifier.source, library);
-    } else if (isSet) {
-      return new Selector.setter(identifier.source, library);
-    }
-
-    // Compute the arity and the list of named arguments.
-    int arity = 0;
-    List<String> named = <String>[];
-    for (Link<Node> link = node.argumentsNode.nodes;
-        !link.isEmpty;
-        link = link.tail) {
-      Expression argument = link.head;
-      NamedArgument namedArgument = argument.asNamedArgument();
-      if (namedArgument != null) {
-        named.add(namedArgument.name.source);
-      }
-      arity++;
-    }
-
-    if (element != null && element.isConstructor) {
-      return new Selector.callConstructor(
-          element.name, library, arity, named);
-    }
-
-    // If we're invoking a closure, we do not have an identifier.
-    return (identifier == null)
-        ? new Selector.callClosure(arity, named)
-        : new Selector.call(identifier.source, library, arity, named);
-  }
-
-  Selector resolveSelector(Send node, Element element) {
-    LibraryElement library = enclosingElement.library;
-    Selector selector = computeSendSelector(node, library, element);
-    if (selector != null) registry.setSelector(node, selector);
-    return selector;
-  }
-
-  void resolveArguments(NodeList list) {
-    if (list == null) return;
-    bool oldSendIsMemberAccess = sendIsMemberAccess;
-    sendIsMemberAccess = false;
-    Map<String, Node> seenNamedArguments = new Map<String, Node>();
-    for (Link<Node> link = list.nodes; !link.isEmpty; link = link.tail) {
-      Expression argument = link.head;
-      visit(argument);
-      NamedArgument namedArgument = argument.asNamedArgument();
-      if (namedArgument != null) {
-        String source = namedArgument.name.source;
-        if (seenNamedArguments.containsKey(source)) {
-          reportDuplicateDefinition(
-              source,
-              argument,
-              seenNamedArguments[source]);
-        } else {
-          seenNamedArguments[source] = namedArgument;
-        }
-      } else if (!seenNamedArguments.isEmpty) {
-        error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
-      }
-    }
-    sendIsMemberAccess = oldSendIsMemberAccess;
-  }
-
-  ResolutionResult visitSend(Send node) {
-    bool oldSendIsMemberAccess = sendIsMemberAccess;
-    sendIsMemberAccess = node.isPropertyAccess || node.isCall;
-    ResolutionResult result;
-    if (node.isLogicalAnd) {
-      result = doInPromotionScope(node.receiver, () => resolveSend(node));
-    } else {
-      result = resolveSend(node);
-    }
-    sendIsMemberAccess = oldSendIsMemberAccess;
-
-    Element target = result != null ? result.element : null;
-
-    if (target != null
-        && target == compiler.mirrorSystemGetNameFunction
-        && !compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
-      compiler.reportHint(
-          node.selector, MessageKind.STATIC_FUNCTION_BLOAT,
-          {'class': compiler.mirrorSystemClass.name,
-           'name': compiler.mirrorSystemGetNameFunction.name});
-    }
-
-    if (!Elements.isUnresolved(target)) {
-      if (target.isAbstractField) {
-        AbstractFieldElement field = target;
-        target = field.getter;
-        if (target == null && !inInstanceContext) {
-          registry.registerThrowNoSuchMethod();
-          target =
-              warnAndCreateErroneousElement(node.selector, field.name,
-                                            MessageKind.CANNOT_RESOLVE_GETTER);
-        }
-      } else if (target.isTypeVariable) {
-        ClassElement cls = target.enclosingClass;
-        assert(enclosingElement.enclosingClass == cls);
-        registry.registerClassUsingVariableExpression(cls);
-        registry.registerTypeVariableExpression();
-        // Set the type of the node to [Type] to mark this send as a
-        // type variable expression.
-        registry.registerTypeLiteral(node, target.computeType(compiler));
-      } else if (target.impliesType && (!sendIsMemberAccess || node.isCall)) {
-        // Set the type of the node to [Type] to mark this send as a
-        // type literal.
-        DartType type;
-
-        // TODO(johnniwinther): Remove this hack when we can pass more complex
-        // information between methods than resolved elements.
-        if (target == compiler.typeClass && node.receiver == null) {
-          // Potentially a 'dynamic' type literal.
-          type = registry.getType(node.selector);
-        }
-        if (type == null) {
-          type = target.computeType(compiler);
-        }
-        registry.registerTypeLiteral(node, type);
-
-        // Don't try to make constants of calls to type literals.
-        if (!node.isCall) {
-          analyzeConstant(node);
-        } else {
-          // The node itself is not a constant but we register the selector (the
-          // identifier that refers to the class/typedef) as a constant.
-          analyzeConstant(node.selector);
-        }
-      }
-      if (isPotentiallyMutableTarget(target)) {
-        if (enclosingElement != target.enclosingElement) {
-          for (Node scope in promotionScope) {
-            registry.setAccessedByClosureIn(scope, target, node);
-          }
-        }
-      }
-    }
-
-    bool resolvedArguments = false;
-    if (node.isOperator) {
-      String operatorString = node.selector.asOperator().source;
-      if (identical(operatorString, 'is')) {
-        // TODO(johnniwinther): Use seen type tests to avoid registration of
-        // mutation/access to unpromoted variables.
-        DartType type =
-            resolveTypeAnnotation(node.typeAnnotationFromIsCheckOrCast);
-        if (type != null) {
-          registry.registerIsCheck(type);
-        }
-        resolvedArguments = true;
-      } else if (identical(operatorString, 'as')) {
-        DartType type = resolveTypeAnnotation(node.arguments.head);
-        if (type != null) {
-          registry.registerAsCheck(type);
-        }
-        resolvedArguments = true;
-      } else if (identical(operatorString, '&&')) {
-        doInPromotionScope(node.arguments.head,
-            () => resolveArguments(node.argumentsNode));
-        resolvedArguments = true;
-      }
-    }
-
-    if (!resolvedArguments) {
-      resolveArguments(node.argumentsNode);
-    }
-
-    // If the selector is null, it means that we will not be generating
-    // code for this as a send.
-    Selector selector = registry.getSelector(node);
-    if (selector == null) return null;
-
-    if (node.isCall) {
-      if (Elements.isUnresolved(target) ||
-          target.isGetter ||
-          target.isField ||
-          Elements.isClosureSend(node, target)) {
-        // If we don't know what we're calling or if we are calling a getter,
-        // we need to register that fact that we may be calling a closure
-        // with the same arguments.
-        Selector call = new Selector.callClosureFrom(selector);
-        registry.registerDynamicInvocation(call);
-      } else if (target.impliesType) {
-        // We call 'call()' on a Type instance returned from the reference to a
-        // class or typedef literal. We do not need to register this call as a
-        // dynamic invocation, because we statically know what the target is.
-      } else {
-        if (target is FunctionElement) {
-          FunctionElement function = target;
-          function.computeSignature(compiler);
-        }
-        if (!selector.applies(target, compiler.world)) {
-          registry.registerThrowNoSuchMethod();
-          if (node.isSuperCall) {
-            // Similar to what we do when we can't find super via selector
-            // in [resolveSend] above, we still need to register the invocation,
-            // because we might call [:super.noSuchMethod:] which calls
-            // [JSInvocationMirror._invokeOn].
-            registry.registerDynamicInvocation(selector);
-            registry.registerSuperNoSuchMethod();
-          }
-        }
-      }
-
-      if (target != null && target.isForeign(compiler.backend)) {
-        if (selector.name == 'JS') {
-          registry.registerJsCall(node, this);
-        } else if (selector.name == 'JS_EMBEDDED_GLOBAL') {
-          registry.registerJsEmbeddedGlobalCall(node, this);
-        } else if (selector.name == 'JS_INTERCEPTOR_CONSTANT') {
-          if (!node.argumentsNode.isEmpty) {
-            Node argument = node.argumentsNode.nodes.head;
-            if (argumentsToJsInterceptorConstant == null) {
-              argumentsToJsInterceptorConstant = new Set<Node>();
-            }
-            argumentsToJsInterceptorConstant.add(argument);
-          }
-        }
-      }
-    }
-
-    registry.useElement(node, target);
-    registerSend(selector, target);
-    if (node.isPropertyAccess && Elements.isStaticOrTopLevelFunction(target)) {
-      registry.registerGetOfStaticFunction(target.declaration);
-    }
-    return node.isPropertyAccess ? new ElementResult(target) : null;
-  }
-
-  /// Callback for native enqueuer to parse a type.  Returns [:null:] on error.
-  DartType resolveTypeFromString(Node node, String typeName) {
-    Element element = lookupInScope(compiler, node,
-                                    scope, typeName);
-    if (element == null) return null;
-    if (element is! ClassElement) return null;
-    ClassElement cls = element;
-    cls.ensureResolved(compiler);
-    return cls.computeType(compiler);
-  }
-
-  ResolutionResult visitSendSet(SendSet node) {
-    bool oldSendIsMemberAccess = sendIsMemberAccess;
-    sendIsMemberAccess = node.isPropertyAccess || node.isCall;
-    ResolutionResult result = resolveSend(node);
-    sendIsMemberAccess = oldSendIsMemberAccess;
-    Element target = result != null ? result.element : null;
-    Element setter = target;
-    Element getter = target;
-    String operatorName = node.assignmentOperator.source;
-    String source = operatorName;
-    bool isComplex = !identical(source, '=');
-    if (!(result is AssertResult || Elements.isUnresolved(target))) {
-      if (target.isAbstractField) {
-        AbstractFieldElement field = target;
-        setter = field.setter;
-        getter = field.getter;
-        if (setter == null && !inInstanceContext) {
-          setter = warnAndCreateErroneousElement(
-              node.selector, field.name, MessageKind.CANNOT_RESOLVE_SETTER);
-          registry.registerThrowNoSuchMethod();
-        }
-        if (isComplex && getter == null && !inInstanceContext) {
-          getter = warnAndCreateErroneousElement(
-              node.selector, field.name, MessageKind.CANNOT_RESOLVE_GETTER);
-          registry.registerThrowNoSuchMethod();
-        }
-      } else if (target.impliesType) {
-        setter = warnAndCreateErroneousElement(
-            node.selector, target.name, MessageKind.ASSIGNING_TYPE);
-        registry.registerThrowNoSuchMethod();
-      } else if (target.isFinal ||
-                 target.isConst ||
-                 (target.isFunction &&
-                  Elements.isStaticOrTopLevelFunction(target) &&
-                  !target.isSetter)) {
-        if (target.isFunction) {
-          setter = warnAndCreateErroneousElement(
-              node.selector, target.name, MessageKind.ASSIGNING_METHOD);
-        } else {
-          setter = warnAndCreateErroneousElement(
-              node.selector, target.name, MessageKind.CANNOT_RESOLVE_SETTER);
-        }
-        registry.registerThrowNoSuchMethod();
-      }
-      if (isPotentiallyMutableTarget(target)) {
-        registry.registerPotentialMutation(target, node);
-        if (enclosingElement != target.enclosingElement) {
-          registry.registerPotentialMutationInClosure(target, node);
-        }
-        for (Node scope in promotionScope) {
-          registry.registerPotentialMutationIn(scope, target, node);
-        }
-      }
-    }
-
-    resolveArguments(node.argumentsNode);
-
-    Selector selector = registry.getSelector(node);
-    if (isComplex) {
-      Selector getterSelector;
-      if (selector.isSetter) {
-        getterSelector = new Selector.getterFrom(selector);
-      } else {
-        assert(selector.isIndexSet);
-        getterSelector = new Selector.index();
-      }
-      registerSend(getterSelector, getter);
-      registry.setGetterSelectorInComplexSendSet(node, getterSelector);
-      if (node.isSuperCall) {
-        getter = currentClass.lookupSuperSelector(getterSelector);
-        if (getter == null) {
-          target = warnAndCreateErroneousElement(
-              node, selector.name, MessageKind.NO_SUCH_SUPER_MEMBER,
-              {'className': currentClass, 'memberName': selector.name});
-          registry.registerSuperNoSuchMethod();
-        }
-      }
-      registry.useElement(node.selector, getter);
-
-      // Make sure we include the + and - operators if we are using
-      // the ++ and -- ones.  Also, if op= form is used, include op itself.
-      void registerBinaryOperator(String name) {
-        Selector binop = new Selector.binaryOperator(name);
-        registry.registerDynamicInvocation(binop);
-        registry.setOperatorSelectorInComplexSendSet(node, binop);
-      }
-      if (identical(source, '++')) {
-        registerBinaryOperator('+');
-        registry.registerInstantiatedClass(compiler.intClass);
-      } else if (identical(source, '--')) {
-        registerBinaryOperator('-');
-        registry.registerInstantiatedClass(compiler.intClass);
-      } else if (source.endsWith('=')) {
-        registerBinaryOperator(Elements.mapToUserOperator(operatorName));
-      }
-    }
-
-    registerSend(selector, setter);
-    return new ElementResult(registry.useElement(node, setter));
-  }
-
-  void registerSend(Selector selector, Element target) {
-    if (target == null || target.isInstanceMember) {
-      if (selector.isGetter) {
-        registry.registerDynamicGetter(selector);
-      } else if (selector.isSetter) {
-        registry.registerDynamicSetter(selector);
-      } else {
-        registry.registerDynamicInvocation(selector);
-      }
-    } else if (Elements.isStaticOrTopLevel(target)) {
-      // Avoid registration of type variables since they are not analyzable but
-      // instead resolved through their enclosing type declaration.
-      if (!target.isTypeVariable) {
-        // [target] might be the implementation element and only declaration
-        // elements may be registered.
-        registry.registerStaticUse(target.declaration);
-      }
-    }
-  }
-
-  visitLiteralInt(LiteralInt node) {
-    registry.registerInstantiatedClass(compiler.intClass);
-  }
-
-  visitLiteralDouble(LiteralDouble node) {
-    registry.registerInstantiatedClass(compiler.doubleClass);
-  }
-
-  visitLiteralBool(LiteralBool node) {
-    registry.registerInstantiatedClass(compiler.boolClass);
-  }
-
-  visitLiteralString(LiteralString node) {
-    registry.registerInstantiatedClass(compiler.stringClass);
-  }
-
-  visitLiteralNull(LiteralNull node) {
-    registry.registerInstantiatedClass(compiler.nullClass);
-  }
-
-  visitLiteralSymbol(LiteralSymbol node) {
-    registry.registerInstantiatedClass(compiler.symbolClass);
-    registry.registerStaticUse(compiler.symbolConstructor.declaration);
-    registry.registerConstSymbol(node.slowNameString);
-    if (!validateSymbol(node, node.slowNameString, reportError: false)) {
-      compiler.reportError(node,
-          MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
-          {'value': node.slowNameString});
-    }
-    analyzeConstant(node);
-  }
-
-  visitStringJuxtaposition(StringJuxtaposition node) {
-    registry.registerInstantiatedClass(compiler.stringClass);
-    node.visitChildren(this);
-  }
-
-  visitNodeList(NodeList node) {
-    for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
-      visit(link.head);
-    }
-  }
-
-  visitOperator(Operator node) {
-    internalError(node, 'operator');
-  }
-
-  visitRethrow(Rethrow node) {
-    if (!inCatchBlock) {
-      error(node, MessageKind.THROW_WITHOUT_EXPRESSION);
-    }
-  }
-
-  visitReturn(Return node) {
-    Node expression = node.expression;
-    if (expression != null &&
-        enclosingElement.isGenerativeConstructor) {
-      // It is a compile-time error if a return statement of the form
-      // `return e;` appears in a generative constructor.  (Dart Language
-      // Specification 13.12.)
-      compiler.reportError(expression,
-                           MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR);
-    }
-    visit(node.expression);
-  }
-
-  visitYield(Yield node) {
-    compiler.streamClass.ensureResolved(compiler);
-    compiler.iterableClass.ensureResolved(compiler);
-    visit(node.expression);
-  }
-
-  visitRedirectingFactoryBody(RedirectingFactoryBody node) {
-    final isSymbolConstructor = enclosingElement == compiler.symbolConstructor;
-    if (!enclosingElement.isFactoryConstructor) {
-      compiler.reportError(
-          node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
-      compiler.reportHint(
-          enclosingElement, MessageKind.MISSING_FACTORY_KEYWORD);
-    }
-    ConstructorElementX constructor = enclosingElement;
-    bool isConstConstructor = constructor.isConst;
-    ConstructorElement redirectionTarget = resolveRedirectingFactory(
-        node, inConstContext: isConstConstructor);
-    constructor.immediateRedirectionTarget = redirectionTarget;
-    registry.setRedirectingTargetConstructor(node, redirectionTarget);
-    if (Elements.isUnresolved(redirectionTarget)) {
-      registry.registerThrowNoSuchMethod();
-      return;
-    } else {
-      if (isConstConstructor &&
-          !redirectionTarget.isConst) {
-        compiler.reportError(node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
-      }
-      if (redirectionTarget == constructor) {
-        compiler.reportError(node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
-        return;
-      }
-    }
-
-    // Check that the target constructor is type compatible with the
-    // redirecting constructor.
-    ClassElement targetClass = redirectionTarget.enclosingClass;
-    InterfaceType type = registry.getType(node);
-    FunctionType targetType = redirectionTarget.computeType(compiler)
-        .subst(type.typeArguments, targetClass.typeVariables);
-    FunctionType constructorType = constructor.computeType(compiler);
-    bool isSubtype = compiler.types.isSubtype(targetType, constructorType);
-    if (!isSubtype) {
-      warning(node, MessageKind.NOT_ASSIGNABLE,
-              {'fromType': targetType, 'toType': constructorType});
-    }
-
-    FunctionSignature targetSignature =
-        redirectionTarget.computeSignature(compiler);
-    FunctionSignature constructorSignature =
-        constructor.computeSignature(compiler);
-    if (!targetSignature.isCompatibleWith(constructorSignature)) {
-      assert(!isSubtype);
-      registry.registerThrowNoSuchMethod();
-    }
-
-    // Register a post process to check for cycles in the redirection chain and
-    // set the actual generative constructor at the end of the chain.
-    addDeferredAction(constructor, () {
-      compiler.resolver.resolveRedirectionChain(constructor, node);
-    });
-
-    registry.registerStaticUse(redirectionTarget);
-    // TODO(johnniwinther): Register the effective target type instead.
-    registry.registerInstantiatedClass(
-        redirectionTarget.enclosingClass.declaration);
-    if (isSymbolConstructor) {
-      registry.registerSymbolConstructor();
-    }
-  }
-
-  visitThrow(Throw node) {
-    registry.registerThrowExpression();
-    visit(node.expression);
-  }
-
-  visitAwait(Await node) {
-    compiler.futureClass.ensureResolved(compiler);
-    visit(node.expression);
-  }
-
-  visitVariableDefinitions(VariableDefinitions node) {
-    DartType type;
-    if (node.type != null) {
-      type = resolveTypeAnnotation(node.type);
-    } else {
-      type = const DynamicType();
-    }
-    VariableList variables = new VariableList.node(node, type);
-    VariableDefinitionsVisitor visitor =
-        new VariableDefinitionsVisitor(compiler, node, this, variables);
-
-    Modifiers modifiers = node.modifiers;
-    void reportExtraModifier(String modifier) {
-      Node modifierNode;
-      for (Link<Node> nodes = modifiers.nodes.nodes;
-           !nodes.isEmpty;
-           nodes = nodes.tail) {
-        if (modifier == nodes.head.asIdentifier().source) {
-          modifierNode = nodes.head;
-          break;
-        }
-      }
-      assert(modifierNode != null);
-      compiler.reportError(modifierNode, MessageKind.EXTRANEOUS_MODIFIER,
-          {'modifier': modifier});
-    }
-    if (modifiers.isFinal && (modifiers.isConst || modifiers.isVar)) {
-      reportExtraModifier('final');
-    }
-    if (modifiers.isVar && (modifiers.isConst || node.type != null)) {
-      reportExtraModifier('var');
-    }
-    if (enclosingElement.isFunction) {
-      if (modifiers.isAbstract) {
-        reportExtraModifier('abstract');
-      }
-      if (modifiers.isStatic) {
-        reportExtraModifier('static');
-      }
-    }
-    if (node.metadata != null) {
-      variables.metadata =
-          compiler.resolver.resolveMetadata(enclosingElement, node);
-    }
-    visitor.visit(node.definitions);
-  }
-
-  visitWhile(While node) {
-    visit(node.condition);
-    visitLoopBodyIn(node, node.body, new BlockScope(scope));
-  }
-
-  visitParenthesizedExpression(ParenthesizedExpression node) {
-    bool oldSendIsMemberAccess = sendIsMemberAccess;
-    sendIsMemberAccess = false;
-    visit(node.expression);
-    sendIsMemberAccess = oldSendIsMemberAccess;
-  }
-
-  ResolutionResult visitNewExpression(NewExpression node) {
-    Node selector = node.send.selector;
-    FunctionElement constructor = resolveConstructor(node);
-    final bool isSymbolConstructor = constructor == compiler.symbolConstructor;
-    final bool isMirrorsUsedConstant =
-        node.isConst && (constructor == compiler.mirrorsUsedConstructor);
-    Selector callSelector = resolveSelector(node.send, constructor);
-    resolveArguments(node.send.argumentsNode);
-    registry.useElement(node.send, constructor);
-    if (Elements.isUnresolved(constructor)) {
-      return new ElementResult(constructor);
-    }
-    constructor.computeSignature(compiler);
-    if (!callSelector.applies(constructor, compiler.world)) {
-      registry.registerThrowNoSuchMethod();
-    }
-
-    // [constructor] might be the implementation element
-    // and only declaration elements may be registered.
-    registry.registerStaticUse(constructor.declaration);
-    ClassElement cls = constructor.enclosingClass;
-    InterfaceType type = registry.getType(node);
-    if (node.isConst && type.containsTypeVariables) {
-      compiler.reportError(node.send.selector,
-                           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
-    }
-    // TODO(johniwinther): Avoid registration of `type` in face of redirecting
-    // factory constructors.
-    registry.registerInstantiatedType(type);
-    if (constructor.isFactoryConstructor && !type.typeArguments.isEmpty) {
-      registry.registerFactoryWithTypeArguments();
-    }
-    if (constructor.isGenerativeConstructor && cls.isAbstract) {
-      warning(node, MessageKind.ABSTRACT_CLASS_INSTANTIATION);
-      registry.registerAbstractClassInstantiation();
-    }
-
-    if (isSymbolConstructor) {
-      if (node.isConst) {
-        Node argumentNode = node.send.arguments.head;
-        ConstantExpression constant =
-            compiler.resolver.constantCompiler.compileNode(
-                argumentNode, registry.mapping);
-        ConstantValue name = constant.value;
-        if (!name.isString) {
-          DartType type = name.computeType(compiler);
-          compiler.reportError(argumentNode, MessageKind.STRING_EXPECTED,
-                                   {'type': type});
-        } else {
-          StringConstantValue stringConstant = name;
-          String nameString = stringConstant.toDartString().slowToString();
-          if (validateSymbol(argumentNode, nameString)) {
-            registry.registerConstSymbol(nameString);
-          }
-        }
-      } else {
-        if (!compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(
-                enclosingElement)) {
-          compiler.reportHint(
-              node.newToken, MessageKind.NON_CONST_BLOAT,
-              {'name': compiler.symbolClass.name});
-        }
-        registry.registerNewSymbol();
-      }
-    } else if (isMirrorsUsedConstant) {
-      compiler.mirrorUsageAnalyzerTask.validate(node, registry.mapping);
-    }
-    if (node.isConst) {
-      analyzeConstant(node);
-    }
-
-    return null;
-  }
-
-  void checkConstMapKeysDontOverrideEquals(Spannable spannable,
-                                           MapConstantValue map) {
-    for (ConstantValue key in map.keys) {
-      if (!key.isObject) continue;
-      ObjectConstantValue objectConstant = key;
-      DartType keyType = objectConstant.type;
-      ClassElement cls = keyType.element;
-      if (cls == compiler.stringClass) continue;
-      Element equals = cls.lookupMember('==');
-      if (equals.enclosingClass != compiler.objectClass) {
-        compiler.reportError(spannable,
-                             MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
-                             {'type': keyType});
-      }
-    }
-  }
-
-  void analyzeConstant(Node node) {
-    addDeferredAction(enclosingElement, () {
-      ConstantExpression constant =
-          compiler.resolver.constantCompiler.compileNode(
-              node, registry.mapping);
-
-      ConstantValue value = constant.value;
-      if (value.isMap) {
-        checkConstMapKeysDontOverrideEquals(node, value);
-      }
-
-      // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
-      // a class that will be instantiated outside the program by attaching a
-      // native class dispatch record referencing the interceptor.
-      if (argumentsToJsInterceptorConstant != null &&
-          argumentsToJsInterceptorConstant.contains(node)) {
-        if (value.isType) {
-          TypeConstantValue typeConstant = value;
-          if (typeConstant.representedType is InterfaceType) {
-            registry.registerInstantiatedType(typeConstant.representedType);
-          } else {
-            compiler.reportError(node,
-                MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
-          }
-        } else {
-          compiler.reportError(node,
-              MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
-        }
-      }
-    });
-  }
-
-  bool validateSymbol(Node node, String name, {bool reportError: true}) {
-    if (name.isEmpty) return true;
-    if (name.startsWith('_')) {
-      if (reportError) {
-        compiler.reportError(node, MessageKind.PRIVATE_IDENTIFIER,
-                             {'value': name});
-      }
-      return false;
-    }
-    if (!symbolValidationPattern.hasMatch(name)) {
-      if (reportError) {
-        compiler.reportError(node, MessageKind.INVALID_SYMBOL,
-                             {'value': name});
-      }
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Try to resolve the constructor that is referred to by [node].
-   * Note: this function may return an ErroneousFunctionElement instead of
-   * [:null:], if there is no corresponding constructor, class or library.
-   */
-  ConstructorElement resolveConstructor(NewExpression node) {
-    return node.accept(new ConstructorResolver(compiler, this));
-  }
-
-  ConstructorElement resolveRedirectingFactory(RedirectingFactoryBody node,
-                                               {bool inConstContext: false}) {
-    return node.accept(new ConstructorResolver(compiler, this,
-                                               inConstContext: inConstContext));
-  }
-
-  DartType resolveTypeAnnotation(TypeAnnotation node,
-                                 {bool malformedIsError: false,
-                                  bool deferredIsMalformed: true}) {
-    DartType type = typeResolver.resolveTypeAnnotation(
-        this, node, malformedIsError: malformedIsError,
-        deferredIsMalformed: deferredIsMalformed);
-    if (inCheckContext) {
-      registry.registerIsCheck(type);
-      registry.registerRequiredType(type, enclosingElement);
-    }
-    return type;
-  }
-
-  visitModifiers(Modifiers node) {
-    internalError(node, 'modifiers');
-  }
-
-  visitLiteralList(LiteralList node) {
-    bool oldSendIsMemberAccess = sendIsMemberAccess;
-    sendIsMemberAccess = false;
-
-    NodeList arguments = node.typeArguments;
-    DartType typeArgument;
-    if (arguments != null) {
-      Link<Node> nodes = arguments.nodes;
-      if (nodes.isEmpty) {
-        // The syntax [: <>[] :] is not allowed.
-        error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
-      } else {
-        typeArgument = resolveTypeAnnotation(nodes.head);
-        for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
-          warning(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
-          resolveTypeAnnotation(nodes.head);
-        }
-      }
-    }
-    DartType listType;
-    if (typeArgument != null) {
-      if (node.isConst && typeArgument.containsTypeVariables) {
-        compiler.reportError(arguments.nodes.head,
-            MessageKind.TYPE_VARIABLE_IN_CONSTANT);
-      }
-      listType = new InterfaceType(compiler.listClass, [typeArgument]);
-    } else {
-      compiler.listClass.computeType(compiler);
-      listType = compiler.listClass.rawType;
-    }
-    registry.setType(node, listType);
-    registry.registerInstantiatedType(listType);
-    registry.registerRequiredType(listType, enclosingElement);
-    visit(node.elements);
-    if (node.isConst) {
-      analyzeConstant(node);
-    }
-
-    sendIsMemberAccess = false;
-  }
-
-  visitConditional(Conditional node) {
-    doInPromotionScope(node.condition, () => visit(node.condition));
-    doInPromotionScope(node.thenExpression, () => visit(node.thenExpression));
-    visit(node.elseExpression);
-  }
-
-  visitStringInterpolation(StringInterpolation node) {
-    registry.registerInstantiatedClass(compiler.stringClass);
-    registry.registerStringInterpolation();
-    node.visitChildren(this);
-  }
-
-  visitStringInterpolationPart(StringInterpolationPart node) {
-    registerImplicitInvocation('toString', 0);
-    node.visitChildren(this);
-  }
-
-  visitBreakStatement(BreakStatement node) {
-    JumpTarget target;
-    if (node.target == null) {
-      target = statementScope.currentBreakTarget();
-      if (target == null) {
-        error(node, MessageKind.NO_BREAK_TARGET);
-        return;
-      }
-      target.isBreakTarget = true;
-    } else {
-      String labelName = node.target.source;
-      LabelDefinition label = statementScope.lookupLabel(labelName);
-      if (label == null) {
-        error(node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
-        return;
-      }
-      target = label.target;
-      if (!target.statement.isValidBreakTarget()) {
-        error(node.target, MessageKind.INVALID_BREAK);
-        return;
-      }
-      label.setBreakTarget();
-      registry.useLabel(node, label);
-    }
-    registry.registerTargetOf(node, target);
-  }
-
-  visitContinueStatement(ContinueStatement node) {
-    JumpTarget target;
-    if (node.target == null) {
-      target = statementScope.currentContinueTarget();
-      if (target == null) {
-        error(node, MessageKind.NO_CONTINUE_TARGET);
-        return;
-      }
-      target.isContinueTarget = true;
-    } else {
-      String labelName = node.target.source;
-      LabelDefinition label = statementScope.lookupLabel(labelName);
-      if (label == null) {
-        error(node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
-        return;
-      }
-      target = label.target;
-      if (!target.statement.isValidContinueTarget()) {
-        error(node.target, MessageKind.INVALID_CONTINUE);
-      }
-      label.setContinueTarget();
-      registry.useLabel(node, label);
-    }
-    registry.registerTargetOf(node, target);
-  }
-
-  registerImplicitInvocation(String name, int arity) {
-    Selector selector = new Selector.call(name, null, arity);
-    registry.registerDynamicInvocation(selector);
-  }
-
-  visitForIn(ForIn node) {
-    LibraryElement library = enclosingElement.library;
-    registry.setIteratorSelector(node, compiler.iteratorSelector);
-    registry.registerDynamicGetter(compiler.iteratorSelector);
-    registry.setCurrentSelector(node, compiler.currentSelector);
-    registry.registerDynamicGetter(compiler.currentSelector);
-    registry.setMoveNextSelector(node, compiler.moveNextSelector);
-    registry.registerDynamicInvocation(compiler.moveNextSelector);
-
-    visit(node.expression);
-    Scope blockScope = new BlockScope(scope);
-    Node declaration = node.declaredIdentifier;
-
-    bool oldAllowFinalWithoutInitializer = allowFinalWithoutInitializer;
-    allowFinalWithoutInitializer = true;
-    visitIn(declaration, blockScope);
-    allowFinalWithoutInitializer = oldAllowFinalWithoutInitializer;
-
-    Send send = declaration.asSend();
-    VariableDefinitions variableDefinitions =
-        declaration.asVariableDefinitions();
-    Element loopVariable;
-    Selector loopVariableSelector;
-    if (send != null) {
-      loopVariable = registry.getDefinition(send);
-      Identifier identifier = send.selector.asIdentifier();
-      if (identifier == null) {
-        compiler.reportError(send.selector, MessageKind.INVALID_FOR_IN);
-      } else {
-        loopVariableSelector = new Selector.setter(identifier.source, library);
-      }
-      if (send.receiver != null) {
-        compiler.reportError(send.receiver, MessageKind.INVALID_FOR_IN);
-      }
-    } else if (variableDefinitions != null) {
-      Link<Node> nodes = variableDefinitions.definitions.nodes;
-      if (!nodes.tail.isEmpty) {
-        compiler.reportError(nodes.tail.head, MessageKind.INVALID_FOR_IN);
-      }
-      Node first = nodes.head;
-      Identifier identifier = first.asIdentifier();
-      if (identifier == null) {
-        compiler.reportError(first, MessageKind.INVALID_FOR_IN);
-      } else {
-        loopVariableSelector = new Selector.setter(identifier.source, library);
-        loopVariable = registry.getDefinition(identifier);
-      }
-    } else {
-      compiler.reportError(declaration, MessageKind.INVALID_FOR_IN);
-    }
-    if (loopVariableSelector != null) {
-      registry.setSelector(declaration, loopVariableSelector);
-      registerSend(loopVariableSelector, loopVariable);
-    } else {
-      // The selector may only be null if we reported an error.
-      assert(invariant(declaration, compiler.compilationFailed));
-    }
-    if (loopVariable != null) {
-      // loopVariable may be null if it could not be resolved.
-      registry.setForInVariable(node, loopVariable);
-    }
-    visitLoopBodyIn(node, node.body, blockScope);
-  }
-
-  visitLabel(Label node) {
-    // Labels are handled by their containing statements/cases.
-  }
-
-  visitLabeledStatement(LabeledStatement node) {
-    Statement body = node.statement;
-    JumpTarget targetElement = getOrDefineTarget(body);
-    Map<String, LabelDefinition> labelElements = <String, LabelDefinition>{};
-    for (Label label in node.labels) {
-      String labelName = label.labelName;
-      if (labelElements.containsKey(labelName)) continue;
-      LabelDefinition element = targetElement.addLabel(label, labelName);
-      labelElements[labelName] = element;
-    }
-    statementScope.enterLabelScope(labelElements);
-    visit(node.statement);
-    statementScope.exitLabelScope();
-    labelElements.forEach((String labelName, LabelDefinition element) {
-      if (element.isTarget) {
-        registry.defineLabel(element.label, element);
-      } else {
-        warning(element.label, MessageKind.UNUSED_LABEL,
-                {'labelName': labelName});
-      }
-    });
-    if (!targetElement.isTarget) {
-      registry.undefineTarget(body);
-    }
-  }
-
-  visitLiteralMap(LiteralMap node) {
-    bool oldSendIsMemberAccess = sendIsMemberAccess;
-    sendIsMemberAccess = false;
-
-    NodeList arguments = node.typeArguments;
-    DartType keyTypeArgument;
-    DartType valueTypeArgument;
-    if (arguments != null) {
-      Link<Node> nodes = arguments.nodes;
-      if (nodes.isEmpty) {
-        // The syntax [: <>{} :] is not allowed.
-        error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
-      } else {
-        keyTypeArgument = resolveTypeAnnotation(nodes.head);
-        nodes = nodes.tail;
-        if (nodes.isEmpty) {
-          warning(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
-        } else {
-          valueTypeArgument = resolveTypeAnnotation(nodes.head);
-          for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
-            warning(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
-            resolveTypeAnnotation(nodes.head);
-          }
-        }
-      }
-    }
-    DartType mapType;
-    if (valueTypeArgument != null) {
-      mapType = new InterfaceType(compiler.mapClass,
-          [keyTypeArgument, valueTypeArgument]);
-    } else {
-      compiler.mapClass.computeType(compiler);
-      mapType = compiler.mapClass.rawType;
-    }
-    if (node.isConst && mapType.containsTypeVariables) {
-      compiler.reportError(arguments,
-          MessageKind.TYPE_VARIABLE_IN_CONSTANT);
-    }
-    registry.setType(node, mapType);
-    registry.registerInstantiatedType(mapType);
-    if (node.isConst) {
-      registry.registerConstantMap();
-    }
-    registry.registerRequiredType(mapType, enclosingElement);
-    node.visitChildren(this);
-    if (node.isConst) {
-      analyzeConstant(node);
-    }
-
-    sendIsMemberAccess = false;
-  }
-
-  visitLiteralMapEntry(LiteralMapEntry node) {
-    node.visitChildren(this);
-  }
-
-  visitNamedArgument(NamedArgument node) {
-    visit(node.expression);
-  }
-
-  DartType typeOfConstant(ConstantValue constant) {
-    if (constant.isInt) return compiler.intClass.rawType;
-    if (constant.isBool) return compiler.boolClass.rawType;
-    if (constant.isDouble) return compiler.doubleClass.rawType;
-    if (constant.isString) return compiler.stringClass.rawType;
-    if (constant.isNull) return compiler.nullClass.rawType;
-    if (constant.isFunction) return compiler.functionClass.rawType;
-    assert(constant.isObject);
-    ObjectConstantValue objectConstant = constant;
-    return objectConstant.type;
-  }
-
-  bool overridesEquals(DartType type) {
-    ClassElement cls = type.element;
-    Element equals = cls.lookupMember('==');
-    return equals.enclosingClass != compiler.objectClass;
-  }
-
-  void checkCaseExpressions(SwitchStatement node) {
-    JumpTarget breakElement = getOrDefineTarget(node);
-    Map<String, LabelDefinition> continueLabels = <String, LabelDefinition>{};
-
-    Link<Node> cases = node.cases.nodes;
-    CaseMatch firstCase = null;
-    DartType firstCaseType = null;
-    bool hasReportedProblem = false;
-
-    for (Link<Node> cases = node.cases.nodes;
-         !cases.isEmpty;
-         cases = cases.tail) {
-      SwitchCase switchCase = cases.head;
-
-      for (Node labelOrCase in switchCase.labelsAndCases) {
-        CaseMatch caseMatch = labelOrCase.asCaseMatch();
-        if (caseMatch == null) continue;
-
-        // Analyze the constant.
-        ConstantExpression constant =
-            registry.getConstant(caseMatch.expression);
-        assert(invariant(node, constant != null,
-            message: 'No constant computed for $node'));
-
-        DartType caseType = typeOfConstant(constant.value);
-
-        if (firstCaseType == null) {
-          firstCase = caseMatch;
-          firstCaseType = caseType;
-
-          // We only report the bad type on the first class element. All others
-          // get a "type differs" error.
-          if (caseType.element == compiler.doubleClass) {
-            compiler.reportError(node,
-                                 MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
-                                 {'type': "double"});
-          } else if (caseType.element == compiler.functionClass) {
-            compiler.reportError(node, MessageKind.SWITCH_CASE_FORBIDDEN,
-                                 {'type': "Function"});
-          } else if (constant.value.isObject && overridesEquals(caseType)) {
-            compiler.reportError(firstCase.expression,
-                MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
-                {'type': caseType});
-          }
-        } else {
-          if (caseType != firstCaseType) {
-            if (!hasReportedProblem) {
-              compiler.reportError(
-                  node,
-                  MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL,
-                  {'type': firstCaseType});
-              compiler.reportInfo(
-                  firstCase.expression,
-                  MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
-                  {'type': firstCaseType});
-              hasReportedProblem = true;
-            }
-            compiler.reportInfo(
-                caseMatch.expression,
-                MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
-                {'type': caseType});
-          }
-        }
-      }
-    }
-  }
-
-  visitSwitchStatement(SwitchStatement node) {
-    node.expression.accept(this);
-
-    JumpTarget breakElement = getOrDefineTarget(node);
-    Map<String, LabelDefinition> continueLabels = <String, LabelDefinition>{};
-    Link<Node> cases = node.cases.nodes;
-    while (!cases.isEmpty) {
-      SwitchCase switchCase = cases.head;
-      for (Node labelOrCase in switchCase.labelsAndCases) {
-        CaseMatch caseMatch = labelOrCase.asCaseMatch();
-        if (caseMatch != null) {
-          analyzeConstant(caseMatch.expression);
-          continue;
-        }
-        Label label = labelOrCase;
-        String labelName = label.labelName;
-
-        LabelDefinition existingElement = continueLabels[labelName];
-        if (existingElement != null) {
-          // It's an error if the same label occurs twice in the same switch.
-          compiler.reportError(
-              label,
-              MessageKind.DUPLICATE_LABEL, {'labelName': labelName});
-          compiler.reportInfo(
-              existingElement.label,
-              MessageKind.EXISTING_LABEL, {'labelName': labelName});
-        } else {
-          // It's only a warning if it shadows another label.
-          existingElement = statementScope.lookupLabel(labelName);
-          if (existingElement != null) {
-            compiler.reportWarning(
-                label,
-                MessageKind.DUPLICATE_LABEL, {'labelName': labelName});
-            compiler.reportInfo(
-                existingElement.label,
-                MessageKind.EXISTING_LABEL, {'labelName': labelName});
-          }
-        }
-
-        JumpTarget targetElement = getOrDefineTarget(switchCase);
-        LabelDefinition labelElement = targetElement.addLabel(label, labelName);
-        registry.defineLabel(label, labelElement);
-        continueLabels[labelName] = labelElement;
-      }
-      cases = cases.tail;
-      // Test that only the last case, if any, is a default case.
-      if (switchCase.defaultKeyword != null && !cases.isEmpty) {
-        error(switchCase, MessageKind.INVALID_CASE_DEFAULT);
-      }
-    }
-
-    addDeferredAction(enclosingElement, () {
-      checkCaseExpressions(node);
-    });
-
-    statementScope.enterSwitch(breakElement, continueLabels);
-    node.cases.accept(this);
-    statementScope.exitSwitch();
-
-    // Clean-up unused labels.
-    continueLabels.forEach((String key, LabelDefinition label) {
-      if (!label.isContinueTarget) {
-        JumpTarget targetElement = label.target;
-        SwitchCase switchCase = targetElement.statement;
-        registry.undefineTarget(switchCase);
-        registry.undefineLabel(label.label);
-      }
-    });
-    // TODO(15575): We should warn if we can detect a fall through
-    // error.
-    registry.registerFallThroughError();
-  }
-
-  visitSwitchCase(SwitchCase node) {
-    node.labelsAndCases.accept(this);
-    visitIn(node.statements, new BlockScope(scope));
-  }
-
-  visitCaseMatch(CaseMatch node) {
-    visit(node.expression);
-  }
-
-  visitTryStatement(TryStatement node) {
-    visit(node.tryBlock);
-    if (node.catchBlocks.isEmpty && node.finallyBlock == null) {
-      error(node.getEndToken().next, MessageKind.NO_CATCH_NOR_FINALLY);
-    }
-    visit(node.catchBlocks);
-    visit(node.finallyBlock);
-  }
-
-  visitCatchBlock(CatchBlock node) {
-    registry.registerCatchStatement();
-    // Check that if catch part is present, then
-    // it has one or two formal parameters.
-    VariableDefinitions exceptionDefinition;
-    VariableDefinitions stackTraceDefinition;
-    if (node.formals != null) {
-      Link<Node> formalsToProcess = node.formals.nodes;
-      if (formalsToProcess.isEmpty) {
-        error(node, MessageKind.EMPTY_CATCH_DECLARATION);
-      } else {
-        exceptionDefinition = formalsToProcess.head.asVariableDefinitions();
-        formalsToProcess = formalsToProcess.tail;
-        if (!formalsToProcess.isEmpty) {
-          stackTraceDefinition = formalsToProcess.head.asVariableDefinitions();
-          formalsToProcess = formalsToProcess.tail;
-          if (!formalsToProcess.isEmpty) {
-            for (Node extra in formalsToProcess) {
-              error(extra, MessageKind.EXTRA_CATCH_DECLARATION);
-            }
-          }
-          registry.registerStackTraceInCatch();
-        }
-      }
-
-      // Check that the formals aren't optional and that they have no
-      // modifiers or type.
-      for (Link<Node> link = node.formals.nodes;
-           !link.isEmpty;
-           link = link.tail) {
-        // If the formal parameter is a node list, it means that it is a
-        // sequence of optional parameters.
-        NodeList nodeList = link.head.asNodeList();
-        if (nodeList != null) {
-          error(nodeList, MessageKind.OPTIONAL_PARAMETER_IN_CATCH);
-        } else {
-          VariableDefinitions declaration = link.head;
-          for (Node modifier in declaration.modifiers.nodes) {
-            error(modifier, MessageKind.PARAMETER_WITH_MODIFIER_IN_CATCH);
-          }
-          TypeAnnotation type = declaration.type;
-          if (type != null) {
-            error(type, MessageKind.PARAMETER_WITH_TYPE_IN_CATCH);
-          }
-        }
-      }
-    }
-
-    Scope blockScope = new BlockScope(scope);
-    doInCheckContext(() => visitIn(node.type, blockScope));
-    visitIn(node.formals, blockScope);
-    var oldInCatchBlock = inCatchBlock;
-    inCatchBlock = true;
-    visitIn(node.block, blockScope);
-    inCatchBlock = oldInCatchBlock;
-
-    if (node.type != null && exceptionDefinition != null) {
-      DartType exceptionType = registry.getType(node.type);
-      Node exceptionVariable = exceptionDefinition.definitions.nodes.head;
-      VariableElementX exceptionElement =
-          registry.getDefinition(exceptionVariable);
-      exceptionElement.variables.type = exceptionType;
-    }
-    if (stackTraceDefinition != null) {
-      Node stackTraceVariable = stackTraceDefinition.definitions.nodes.head;
-      VariableElementX stackTraceElement =
-          registry.getDefinition(stackTraceVariable);
-      registry.registerInstantiatedClass(compiler.stackTraceClass);
-      stackTraceElement.variables.type = compiler.stackTraceClass.rawType;
-    }
-  }
-
-  visitTypedef(Typedef node) {
-    internalError(node, 'typedef');
-  }
-}
-
-class TypeDefinitionVisitor extends MappingVisitor<DartType> {
-  Scope scope;
-  final TypeDeclarationElement enclosingElement;
-  TypeDeclarationElement get element => enclosingElement;
-
-  TypeDefinitionVisitor(Compiler compiler,
-                        TypeDeclarationElement element,
-                        ResolutionRegistry registry)
-      : this.enclosingElement = element,
-        scope = Scope.buildEnclosingScope(element),
-        super(compiler, registry);
-
-  DartType get objectType => compiler.objectClass.rawType;
-
-  void resolveTypeVariableBounds(NodeList node) {
-    if (node == null) return;
-
-    Setlet<String> nameSet = new Setlet<String>();
-    // Resolve the bounds of type variables.
-    Iterator<DartType> types = element.typeVariables.iterator;
-    Link<Node> nodeLink = node.nodes;
-    while (!nodeLink.isEmpty) {
-      types.moveNext();
-      TypeVariableType typeVariable = types.current;
-      String typeName = typeVariable.name;
-      TypeVariable typeNode = nodeLink.head;
-      registry.useType(typeNode, typeVariable);
-      if (nameSet.contains(typeName)) {
-        error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME,
-              {'typeVariableName': typeName});
-      }
-      nameSet.add(typeName);
-
-      TypeVariableElementX variableElement = typeVariable.element;
-      if (typeNode.bound != null) {
-        DartType boundType = typeResolver.resolveTypeAnnotation(
-            this, typeNode.bound);
-        variableElement.boundCache = boundType;
-
-        void checkTypeVariableBound() {
-          Link<TypeVariableElement> seenTypeVariables =
-              const Link<TypeVariableElement>();
-          seenTypeVariables = seenTypeVariables.prepend(variableElement);
-          DartType bound = boundType;
-          while (bound.isTypeVariable) {
-            TypeVariableElement element = bound.element;
-            if (seenTypeVariables.contains(element)) {
-              if (identical(element, variableElement)) {
-                // Only report an error on the checked type variable to avoid
-                // generating multiple errors for the same cyclicity.
-                warning(typeNode.name, MessageKind.CYCLIC_TYPE_VARIABLE,
-                    {'typeVariableName': variableElement.name});
-              }
-              break;
-            }
-            seenTypeVariables = seenTypeVariables.prepend(element);
-            bound = element.bound;
-          }
-        }
-        addDeferredAction(element, checkTypeVariableBound);
-      } else {
-        variableElement.boundCache = objectType;
-      }
-      nodeLink = nodeLink.tail;
-    }
-    assert(!types.moveNext());
-  }
-}
-
-class TypedefResolverVisitor extends TypeDefinitionVisitor {
-  TypedefElementX get element => enclosingElement;
-
-  TypedefResolverVisitor(Compiler compiler,
-                         TypedefElement typedefElement,
-                         ResolutionRegistry registry)
-      : super(compiler, typedefElement, registry);
-
-  visitTypedef(Typedef node) {
-    TypedefType type = element.computeType(compiler);
-    scope = new TypeDeclarationScope(scope, element);
-    resolveTypeVariableBounds(node.typeParameters);
-
-    FunctionSignature signature = SignatureResolver.analyze(
-        compiler, node.formals, node.returnType, element, registry,
-        defaultValuesError: MessageKind.TYPEDEF_FORMAL_WITH_DEFAULT);
-    element.functionSignature = signature;
-
-    scope = new MethodScope(scope, element);
-    signature.forEachParameter(addToScope);
-
-    element.alias = signature.type;
-
-    void checkCyclicReference() {
-      element.checkCyclicReference(compiler);
-    }
-    addDeferredAction(element, checkCyclicReference);
-  }
-}
-
-// TODO(johnniwinther): Replace with a traversal on the AST when the type
-// annotations in typedef alias are stored in a [TreeElements] mapping.
-class TypedefCyclicVisitor extends DartTypeVisitor {
-  final Compiler compiler;
-  final TypedefElementX element;
-  bool hasCyclicReference = false;
-
-  Link<TypedefElement> seenTypedefs = const Link<TypedefElement>();
-
-  int seenTypedefsCount = 0;
-
-  Link<TypeVariableElement> seenTypeVariables =
-      const Link<TypeVariableElement>();
-
-  TypedefCyclicVisitor(Compiler this.compiler, TypedefElement this.element);
-
-  visitType(DartType type, _) {
-    // Do nothing.
-  }
-
-  visitTypedefType(TypedefType type, _) {
-    TypedefElementX typedefElement = type.element;
-    if (seenTypedefs.contains(typedefElement)) {
-      if (!hasCyclicReference && identical(element, typedefElement)) {
-        // Only report an error on the checked typedef to avoid generating
-        // multiple errors for the same cyclicity.
-        hasCyclicReference = true;
-        if (seenTypedefsCount == 1) {
-          // Direct cyclicity.
-          compiler.reportError(element,
-              MessageKind.CYCLIC_TYPEDEF,
-              {'typedefName': element.name});
-        } else if (seenTypedefsCount == 2) {
-          // Cyclicity through one other typedef.
-          compiler.reportError(element,
-              MessageKind.CYCLIC_TYPEDEF_ONE,
-              {'typedefName': element.name,
-               'otherTypedefName': seenTypedefs.head.name});
-        } else {
-          // Cyclicity through more than one other typedef.
-          for (TypedefElement cycle in seenTypedefs) {
-            if (!identical(typedefElement, cycle)) {
-              compiler.reportError(element,
-                  MessageKind.CYCLIC_TYPEDEF_ONE,
-                  {'typedefName': element.name,
-                   'otherTypedefName': cycle.name});
-            }
-          }
-        }
-        ErroneousElementX erroneousElement = new ErroneousElementX(
-              MessageKind.CYCLIC_TYPEDEF,
-              {'typedefName': element.name},
-              element.name, element);
-        element.alias =
-            new MalformedType(erroneousElement, typedefElement.alias);
-        element.hasBeenCheckedForCycles = true;
-      }
-    } else {
-      seenTypedefs = seenTypedefs.prepend(typedefElement);
-      seenTypedefsCount++;
-      type.visitChildren(this, null);
-      typedefElement.alias.accept(this, null);
-      seenTypedefs = seenTypedefs.tail;
-      seenTypedefsCount--;
-    }
-  }
-
-  visitFunctionType(FunctionType type, _) {
-    type.visitChildren(this, null);
-  }
-
-  visitInterfaceType(InterfaceType type, _) {
-    type.visitChildren(this, null);
-  }
-
-  visitTypeVariableType(TypeVariableType type, _) {
-    TypeVariableElement typeVariableElement = type.element;
-    if (seenTypeVariables.contains(typeVariableElement)) {
-      // Avoid running in cycles on cyclic type variable bounds.
-      // Cyclicity is reported elsewhere.
-      return;
-    }
-    seenTypeVariables = seenTypeVariables.prepend(typeVariableElement);
-    typeVariableElement.bound.accept(this, null);
-    seenTypeVariables = seenTypeVariables.tail;
-  }
-}
-
-/**
- * The implementation of [ResolverTask.resolveClass].
- *
- * This visitor has to be extra careful as it is building the basic
- * element information, and cannot safely look at other elements as
- * this may lead to cycles.
- *
- * This visitor can assume that the supertypes have already been
- * resolved, but it cannot call [ResolverTask.resolveClass] directly
- * or indirectly (through [ClassElement.ensureResolved]) for any other
- * types.
- */
-class ClassResolverVisitor extends TypeDefinitionVisitor {
-  BaseClassElementX get element => enclosingElement;
-
-  ClassResolverVisitor(Compiler compiler,
-                       ClassElement classElement,
-                       ResolutionRegistry registry)
-    : super(compiler, classElement, registry);
-
-  DartType visitClassNode(ClassNode node) {
-    invariant(node, element != null);
-    invariant(element, element.resolutionState == STATE_STARTED,
-        message: () => 'cyclic resolution of class $element');
-
-    InterfaceType type = element.computeType(compiler);
-    scope = new TypeDeclarationScope(scope, element);
-    // TODO(ahe): It is not safe to call resolveTypeVariableBounds yet.
-    // As a side-effect, this may get us back here trying to
-    // resolve this class again.
-    resolveTypeVariableBounds(node.typeParameters);
-
-    // Setup the supertype for the element (if there is a cycle in the
-    // class hierarchy, it has already been set to Object).
-    if (element.supertype == null && node.superclass != null) {
-      MixinApplication superMixin = node.superclass.asMixinApplication();
-      if (superMixin != null) {
-        DartType supertype = resolveSupertype(element, superMixin.superclass);
-        Link<Node> link = superMixin.mixins.nodes;
-        while (!link.isEmpty) {
-          supertype = applyMixin(supertype,
-                                 checkMixinType(link.head), link.head);
-          link = link.tail;
-        }
-        element.supertype = supertype;
-      } else {
-        element.supertype = resolveSupertype(element, node.superclass);
-      }
-    }
-    // If the super type isn't specified, we provide a default.  The language
-    // specifies [Object] but the backend can pick a specific 'implementation'
-    // of Object - the JavaScript backend chooses between Object and
-    // Interceptor.
-    if (element.supertype == null) {
-      ClassElement superElement = registry.defaultSuperclass(element);
-      // Avoid making the superclass (usually Object) extend itself.
-      if (element != superElement) {
-        if (superElement == null) {
-          compiler.internalError(node,
-              "Cannot resolve default superclass for $element.");
-        } else {
-          superElement.ensureResolved(compiler);
-        }
-        element.supertype = superElement.computeType(compiler);
-      }
-    }
-
-    if (element.interfaces == null) {
-      element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
-    } else {
-      assert(invariant(element, element.hasIncompleteHierarchy));
-    }
-    calculateAllSupertypes(element);
-
-    if (!element.hasConstructor) {
-      Element superMember = element.superclass.localLookup('');
-      if (superMember == null || !superMember.isGenerativeConstructor) {
-        MessageKind kind = MessageKind.CANNOT_FIND_CONSTRUCTOR;
-        Map arguments = {'constructorName': ''};
-        // TODO(ahe): Why is this a compile-time error? Or if it is an error,
-        // why do we bother to registerThrowNoSuchMethod below?
-        compiler.reportError(node, kind, arguments);
-        superMember = new ErroneousElementX(
-            kind, arguments, '', element);
-        registry.registerThrowNoSuchMethod();
-      } else {
-        ConstructorElement superConstructor = superMember;
-        Selector callToMatch = new Selector.call("", element.library, 0);
-        superConstructor.computeSignature(compiler);
-        if (!callToMatch.applies(superConstructor, compiler.world)) {
-          MessageKind kind = MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT;
-          compiler.reportError(node, kind);
-          superMember = new ErroneousElementX(kind, {}, '', element);
-        }
-      }
-      FunctionElement constructor =
-          new SynthesizedConstructorElementX.forDefault(superMember, element);
-      element.setDefaultConstructor(constructor, compiler);
-    }
-    return element.computeType(compiler);
-  }
-
-  /// Resolves the mixed type for [mixinNode] and checks that the the mixin type
-  /// is a valid, non-blacklisted interface type. The mixin type is returned.
-  DartType checkMixinType(TypeAnnotation mixinNode) {
-    DartType mixinType = resolveType(mixinNode);
-    if (isBlackListed(mixinType)) {
-      compiler.reportError(mixinNode,
-          MessageKind.CANNOT_MIXIN, {'type': mixinType});
-    } else if (mixinType.isTypeVariable) {
-      compiler.reportError(mixinNode, MessageKind.CLASS_NAME_EXPECTED);
-    } else if (mixinType.isMalformed) {
-      compiler.reportError(mixinNode, MessageKind.CANNOT_MIXIN_MALFORMED,
-          {'className': element.name, 'malformedType': mixinType});
-    }
-    return mixinType;
-  }
-
-  DartType visitNamedMixinApplication(NamedMixinApplication node) {
-    invariant(node, element != null);
-    invariant(element, element.resolutionState == STATE_STARTED,
-        message: () => 'cyclic resolution of class $element');
-
-    if (identical(node.classKeyword.stringValue, 'typedef')) {
-      // TODO(aprelev@gmail.com): Remove this deprecation diagnostic
-      // together with corresponding TODO in parser.dart.
-      compiler.reportWarning(node.classKeyword,
-          MessageKind.DEPRECATED_TYPEDEF_MIXIN_SYNTAX);
-    }
-
-    InterfaceType type = element.computeType(compiler);
-    scope = new TypeDeclarationScope(scope, element);
-    resolveTypeVariableBounds(node.typeParameters);
-
-    // Generate anonymous mixin application elements for the
-    // intermediate mixin applications (excluding the last).
-    DartType supertype = resolveSupertype(element, node.superclass);
-    Link<Node> link = node.mixins.nodes;
-    while (!link.tail.isEmpty) {
-      supertype = applyMixin(supertype, checkMixinType(link.head), link.head);
-      link = link.tail;
-    }
-    doApplyMixinTo(element, supertype, checkMixinType(link.head));
-    return element.computeType(compiler);
-  }
-
-  DartType applyMixin(DartType supertype, DartType mixinType, Node node) {
-    String superName = supertype.name;
-    String mixinName = mixinType.name;
-    MixinApplicationElementX mixinApplication = new MixinApplicationElementX(
-        "${superName}+${mixinName}",
-        element.compilationUnit,
-        compiler.getNextFreeClassId(),
-        node,
-        new Modifiers.withFlags(new NodeList.empty(), Modifiers.FLAG_ABSTRACT));
-    // Create synthetic type variables for the mixin application.
-    List<DartType> typeVariables = <DartType>[];
-    element.typeVariables.forEach((TypeVariableType type) {
-      TypeVariableElementX typeVariableElement = new TypeVariableElementX(
-          type.name, mixinApplication, type.element.node);
-      TypeVariableType typeVariable = new TypeVariableType(typeVariableElement);
-      typeVariables.add(typeVariable);
-    });
-    // Setup bounds on the synthetic type variables.
-    List<DartType> link = typeVariables;
-    int index = 0;
-    element.typeVariables.forEach((TypeVariableType type) {
-      TypeVariableType typeVariable = typeVariables[index++];
-      TypeVariableElementX typeVariableElement = typeVariable.element;
-      typeVariableElement.typeCache = typeVariable;
-      typeVariableElement.boundCache =
-          type.element.bound.subst(typeVariables, element.typeVariables);
-    });
-    // Setup this and raw type for the mixin application.
-    mixinApplication.computeThisAndRawType(compiler, typeVariables);
-    // Substitute in synthetic type variables in super and mixin types.
-    supertype = supertype.subst(typeVariables, element.typeVariables);
-    mixinType = mixinType.subst(typeVariables, element.typeVariables);
-
-    doApplyMixinTo(mixinApplication, supertype, mixinType);
-    mixinApplication.resolutionState = STATE_DONE;
-    mixinApplication.supertypeLoadState = STATE_DONE;
-    // Replace the synthetic type variables by the original type variables in
-    // the returned type (which should be the type actually extended).
-    InterfaceType mixinThisType = mixinApplication.computeType(compiler);
-    return mixinThisType.subst(element.typeVariables,
-                               mixinThisType.typeArguments);
-  }
-
-  bool isDefaultConstructor(FunctionElement constructor) {
-    return constructor.name == '' &&
-        constructor.computeSignature(compiler).parameterCount == 0;
-  }
-
-  FunctionElement createForwardingConstructor(ConstructorElement target,
-                                              ClassElement enclosing) {
-    return new SynthesizedConstructorElementX(
-        target.name, target, enclosing, false);
-  }
-
-  void doApplyMixinTo(MixinApplicationElementX mixinApplication,
-                      DartType supertype,
-                      DartType mixinType) {
-    Node node = mixinApplication.parseNode(compiler);
-
-    if (mixinApplication.supertype != null) {
-      // [supertype] is not null if there was a cycle.
-      assert(invariant(node, compiler.compilationFailed));
-      supertype = mixinApplication.supertype;
-      assert(invariant(node, supertype.element == compiler.objectClass));
-    } else {
-      mixinApplication.supertype = supertype;
-    }
-
-    // Named mixin application may have an 'implements' clause.
-    NamedMixinApplication namedMixinApplication =
-        node.asNamedMixinApplication();
-    Link<DartType> interfaces = (namedMixinApplication != null)
-        ? resolveInterfaces(namedMixinApplication.interfaces,
-                            namedMixinApplication.superclass)
-        : const Link<DartType>();
-
-    // The class that is the result of a mixin application implements
-    // the interface of the class that was mixed in so always prepend
-    // that to the interface list.
-    if (mixinApplication.interfaces == null) {
-      if (mixinType.isInterfaceType) {
-        // Avoid malformed types in the interfaces.
-        interfaces = interfaces.prepend(mixinType);
-      }
-      mixinApplication.interfaces = interfaces;
-    } else {
-      assert(invariant(mixinApplication,
-          mixinApplication.hasIncompleteHierarchy));
-    }
-
-    ClassElement superclass = supertype.element;
-    if (mixinType.kind != TypeKind.INTERFACE) {
-      mixinApplication.hasIncompleteHierarchy = true;
-      mixinApplication.allSupertypesAndSelf = superclass.allSupertypesAndSelf;
-      return;
-    }
-
-    assert(mixinApplication.mixinType == null);
-    mixinApplication.mixinType = resolveMixinFor(mixinApplication, mixinType);
-
-    // Create forwarding constructors for constructor defined in the superclass
-    // because they are now hidden by the mixin application.
-    superclass.forEachLocalMember((Element member) {
-      if (!member.isGenerativeConstructor) return;
-      FunctionElement forwarder =
-          createForwardingConstructor(member, mixinApplication);
-      if (isPrivateName(member.name) &&
-          mixinApplication.library != superclass.library) {
-        // Do not create a forwarder to the super constructor, because the mixin
-        // application is in a different library than the constructor in the
-        // super class and it is not possible to call that constructor from the
-        // library using the mixin application.
-        return;
-      }
-      mixinApplication.addConstructor(forwarder);
-    });
-    calculateAllSupertypes(mixinApplication);
-  }
-
-  InterfaceType resolveMixinFor(MixinApplicationElement mixinApplication,
-                                DartType mixinType) {
-    ClassElement mixin = mixinType.element;
-    mixin.ensureResolved(compiler);
-
-    // Check for cycles in the mixin chain.
-    ClassElement previous = mixinApplication;  // For better error messages.
-    ClassElement current = mixin;
-    while (current != null && current.isMixinApplication) {
-      MixinApplicationElement currentMixinApplication = current;
-      if (currentMixinApplication == mixinApplication) {
-        compiler.reportError(
-            mixinApplication, MessageKind.ILLEGAL_MIXIN_CYCLE,
-            {'mixinName1': current.name, 'mixinName2': previous.name});
-        // We have found a cycle in the mixin chain. Return null as
-        // the mixin for this application to avoid getting into
-        // infinite recursion when traversing members.
-        return null;
-      }
-      previous = current;
-      current = currentMixinApplication.mixin;
-    }
-    registry.registerMixinUse(mixinApplication, mixin);
-    return mixinType;
-  }
-
-  DartType resolveType(TypeAnnotation node) {
-    return typeResolver.resolveTypeAnnotation(this, node);
-  }
-
-  DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
-    DartType supertype = resolveType(superclass);
-    if (supertype != null) {
-      if (identical(supertype.kind, TypeKind.MALFORMED_TYPE)) {
-        compiler.reportError(superclass, MessageKind.CANNOT_EXTEND_MALFORMED,
-            {'className': element.name, 'malformedType': supertype});
-        return objectType;
-      } else if (!identical(supertype.kind, TypeKind.INTERFACE)) {
-        compiler.reportError(superclass.typeName,
-            MessageKind.CLASS_NAME_EXPECTED);
-        return objectType;
-      } else if (isBlackListed(supertype)) {
-        compiler.reportError(superclass, MessageKind.CANNOT_EXTEND,
-            {'type': supertype});
-        return objectType;
-      }
-    }
-    return supertype;
-  }
-
-  Link<DartType> resolveInterfaces(NodeList interfaces, Node superclass) {
-    Link<DartType> result = const Link<DartType>();
-    if (interfaces == null) return result;
-    for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
-      DartType interfaceType = resolveType(link.head);
-      if (interfaceType != null) {
-        if (identical(interfaceType.kind, TypeKind.MALFORMED_TYPE)) {
-          compiler.reportError(superclass,
-              MessageKind.CANNOT_IMPLEMENT_MALFORMED,
-              {'className': element.name, 'malformedType': interfaceType});
-        } else if (!identical(interfaceType.kind, TypeKind.INTERFACE)) {
-          // TODO(johnniwinther): Handle dynamic.
-          TypeAnnotation typeAnnotation = link.head;
-          error(typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED);
-        } else {
-          if (interfaceType == element.supertype) {
-            compiler.reportError(
-                superclass,
-                MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
-                {'type': interfaceType});
-            compiler.reportError(
-                link.head,
-                MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
-                {'type': interfaceType});
-          }
-          if (result.contains(interfaceType)) {
-            compiler.reportError(
-                link.head,
-                MessageKind.DUPLICATE_IMPLEMENTS,
-                {'type': interfaceType});
-          }
-          result = result.prepend(interfaceType);
-          if (isBlackListed(interfaceType)) {
-            error(link.head, MessageKind.CANNOT_IMPLEMENT,
-                  {'type': interfaceType});
-          }
-        }
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Compute the list of all supertypes.
-   *
-   * The elements of this list are ordered as follows: first the supertype that
-   * the class extends, then the implemented interfaces, and then the supertypes
-   * of these.  The class [Object] appears only once, at the end of the list.
-   *
-   * For example, for a class `class C extends S implements I1, I2`, we compute
-   *   supertypes(C) = [S, I1, I2] ++ supertypes(S) ++ supertypes(I1)
-   *                   ++ supertypes(I2),
-   * where ++ stands for list concatenation.
-   *
-   * This order makes sure that if a class implements an interface twice with
-   * different type arguments, the type used in the most specific class comes
-   * first.
-   */
-  void calculateAllSupertypes(BaseClassElementX cls) {
-    if (cls.allSupertypesAndSelf != null) return;
-    final DartType supertype = cls.supertype;
-    if (supertype != null) {
-      OrderedTypeSetBuilder allSupertypes = new OrderedTypeSetBuilder(cls);
-      // TODO(15296): Collapse these iterations to one when the order is not
-      // needed.
-      allSupertypes.add(compiler, supertype);
-      for (Link<DartType> interfaces = cls.interfaces;
-           !interfaces.isEmpty;
-           interfaces = interfaces.tail) {
-        allSupertypes.add(compiler, interfaces.head);
-      }
-
-      addAllSupertypes(allSupertypes, supertype);
-      for (Link<DartType> interfaces = cls.interfaces;
-           !interfaces.isEmpty;
-           interfaces = interfaces.tail) {
-        addAllSupertypes(allSupertypes, interfaces.head);
-      }
-      allSupertypes.add(compiler, cls.computeType(compiler));
-      cls.allSupertypesAndSelf = allSupertypes.toTypeSet();
-    } else {
-      assert(identical(cls, compiler.objectClass));
-      cls.allSupertypesAndSelf =
-          new OrderedTypeSet.singleton(cls.computeType(compiler));
-    }
-  }
-
-  /**
-   * Adds [type] and all supertypes of [type] to [allSupertypes] while
-   * substituting type variables.
-   */
-  void addAllSupertypes(OrderedTypeSetBuilder allSupertypes,
-                        InterfaceType type) {
-    ClassElement classElement = type.element;
-    Link<DartType> supertypes = classElement.allSupertypes;
-    assert(invariant(element, supertypes != null,
-        message: "Supertypes not computed on $classElement "
-                 "during resolution of $element"));
-    while (!supertypes.isEmpty) {
-      DartType supertype = supertypes.head;
-      allSupertypes.add(compiler, supertype.substByContext(type));
-      supertypes = supertypes.tail;
-    }
-  }
-
-  isBlackListed(DartType type) {
-    LibraryElement lib = element.library;
-    return
-      !identical(lib, compiler.coreLibrary) &&
-      !compiler.backend.isBackendLibrary(lib) &&
-      (type.isDynamic ||
-       identical(type.element, compiler.boolClass) ||
-       identical(type.element, compiler.numClass) ||
-       identical(type.element, compiler.intClass) ||
-       identical(type.element, compiler.doubleClass) ||
-       identical(type.element, compiler.stringClass) ||
-       identical(type.element, compiler.nullClass));
-  }
-}
-
-class ClassSupertypeResolver extends CommonResolverVisitor {
-  Scope context;
-  ClassElement classElement;
-
-  ClassSupertypeResolver(Compiler compiler, ClassElement cls)
-    : context = Scope.buildEnclosingScope(cls),
-      this.classElement = cls,
-      super(compiler);
-
-  void loadSupertype(ClassElement element, Node from) {
-    compiler.resolver.loadSupertypes(element, from);
-    element.ensureResolved(compiler);
-  }
-
-  void visitNodeList(NodeList node) {
-    if (node != null) {
-      for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
-        link.head.accept(this);
-      }
-    }
-  }
-
-  void visitClassNode(ClassNode node) {
-    if (node.superclass == null) {
-      if (!identical(classElement, compiler.objectClass)) {
-        loadSupertype(compiler.objectClass, node);
-      }
-    } else {
-      node.superclass.accept(this);
-    }
-    visitNodeList(node.interfaces);
-  }
-
-  void visitMixinApplication(MixinApplication node) {
-    node.superclass.accept(this);
-    visitNodeList(node.mixins);
-  }
-
-  void visitNamedMixinApplication(NamedMixinApplication node) {
-    node.superclass.accept(this);
-    visitNodeList(node.mixins);
-    visitNodeList(node.interfaces);
-  }
-
-  void visitTypeAnnotation(TypeAnnotation node) {
-    node.typeName.accept(this);
-  }
-
-  void visitIdentifier(Identifier node) {
-    Element element = lookupInScope(compiler, node, context, node.source);
-    if (element != null && element.isClass) {
-      loadSupertype(element, node);
-    }
-  }
-
-  void visitSend(Send node) {
-    Identifier prefix = node.receiver.asIdentifier();
-    if (prefix == null) {
-      error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
-      return;
-    }
-    Element element = lookupInScope(compiler, prefix, context, prefix.source);
-    if (element == null || !identical(element.kind, ElementKind.PREFIX)) {
-      error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
-      return;
-    }
-    PrefixElement prefixElement = element;
-    Identifier selector = node.selector.asIdentifier();
-    var e = prefixElement.lookupLocalMember(selector.source);
-    if (e == null || !e.impliesType) {
-      error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE,
-            {'typeName': node.selector});
-      return;
-    }
-    loadSupertype(e, node);
-  }
-}
-
-class VariableDefinitionsVisitor extends CommonResolverVisitor<Identifier> {
-  VariableDefinitions definitions;
-  ResolverVisitor resolver;
-  VariableList variables;
-
-  VariableDefinitionsVisitor(Compiler compiler,
-                             this.definitions,
-                             this.resolver,
-                             this.variables)
-      : super(compiler) {
-  }
-
-  ResolutionRegistry get registry => resolver.registry;
-
-  Identifier visitSendSet(SendSet node) {
-    assert(node.arguments.tail.isEmpty); // Sanity check
-    Identifier identifier = node.selector;
-    String name = identifier.source;
-    VariableDefinitionScope scope =
-        new VariableDefinitionScope(resolver.scope, name);
-    resolver.visitIn(node.arguments.head, scope);
-    if (scope.variableReferencedInInitializer) {
-      compiler.reportError(
-          identifier, MessageKind.REFERENCE_IN_INITIALIZATION,
-          {'variableName': name});
-    }
-    return identifier;
-  }
-
-  Identifier visitIdentifier(Identifier node) {
-    // The variable is initialized to null.
-    registry.registerInstantiatedClass(compiler.nullClass);
-    if (definitions.modifiers.isConst) {
-      compiler.reportError(node, MessageKind.CONST_WITHOUT_INITIALIZER);
-    }
-    if (definitions.modifiers.isFinal &&
-        !resolver.allowFinalWithoutInitializer) {
-      compiler.reportError(node, MessageKind.FINAL_WITHOUT_INITIALIZER);
-    }
-    return node;
-  }
-
-  visitNodeList(NodeList node) {
-    for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
-      Identifier name = visit(link.head);
-      LocalVariableElement element = new LocalVariableElementX(
-          name.source, resolver.enclosingElement,
-          variables, name.token);
-      resolver.defineLocalVariable(link.head, element);
-      resolver.addToScope(element);
-      if (definitions.modifiers.isConst) {
-        compiler.enqueuer.resolution.addDeferredAction(element, () {
-          compiler.resolver.constantCompiler.compileConstant(element);
-        });
-      }
-    }
-  }
-}
-
-class ConstructorResolver extends CommonResolverVisitor<Element> {
-  final ResolverVisitor resolver;
-  bool inConstContext;
-  DartType type;
-
-  ConstructorResolver(Compiler compiler, this.resolver,
-                      {bool this.inConstContext: false})
-      : super(compiler);
-
-  ResolutionRegistry get registry => resolver.registry;
-
-  visitNode(Node node) {
-    throw 'not supported';
-  }
-
-  failOrReturnErroneousElement(Element enclosing, Node diagnosticNode,
-                               String targetName, MessageKind kind,
-                               Map arguments) {
-    if (kind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
-      registry.registerThrowNoSuchMethod();
-    } else {
-      registry.registerThrowRuntimeError();
-    }
-    if (inConstContext) {
-      compiler.reportError(diagnosticNode, kind, arguments);
-    } else {
-      compiler.reportWarning(diagnosticNode, kind, arguments);
-    }
-    return new ErroneousElementX(kind, arguments, targetName, enclosing);
-  }
-
-  Selector createConstructorSelector(String constructorName) {
-    return constructorName == ''
-        ? new Selector.callDefaultConstructor(
-            resolver.enclosingElement.library)
-        : new Selector.callConstructor(
-            constructorName,
-            resolver.enclosingElement.library);
-  }
-
-  FunctionElement resolveConstructor(ClassElement cls,
-                                     Node diagnosticNode,
-                                     String constructorName) {
-    cls.ensureResolved(compiler);
-    Selector selector = createConstructorSelector(constructorName);
-    Element result = cls.lookupConstructor(selector);
-    if (result == null) {
-      String fullConstructorName = Elements.constructorNameForDiagnostics(
-              cls.name,
-              constructorName);
-      return failOrReturnErroneousElement(
-          cls,
-          diagnosticNode,
-          fullConstructorName,
-          MessageKind.CANNOT_FIND_CONSTRUCTOR,
-          {'constructorName': fullConstructorName});
-    } else if (inConstContext && !result.isConst) {
-      error(diagnosticNode, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
-    }
-    return result;
-  }
-
-  Element visitNewExpression(NewExpression node) {
-    inConstContext = node.isConst;
-    Node selector = node.send.selector;
-    Element element = visit(selector);
-    assert(invariant(selector, element != null,
-        message: 'No element return for $selector.'));
-    return finishConstructorReference(element, node.send.selector, node);
-  }
-
-  /// Finishes resolution of a constructor reference and records the
-  /// type of the constructed instance on [expression].
-  FunctionElement finishConstructorReference(Element element,
-                                             Node diagnosticNode,
-                                             Node expression) {
-    assert(invariant(diagnosticNode, element != null,
-        message: 'No element return for $diagnosticNode.'));
-    // Find the unnamed constructor if the reference resolved to a
-    // class.
-    if (!Elements.isUnresolved(element) && !element.isConstructor) {
-      if (element.isClass) {
-        ClassElement cls = element;
-        cls.ensureResolved(compiler);
-        // The unnamed constructor may not exist, so [e] may become unresolved.
-        element = resolveConstructor(cls, diagnosticNode, '');
-      } else {
-        element = failOrReturnErroneousElement(
-            element, diagnosticNode, element.name, MessageKind.NOT_A_TYPE,
-            {'node': diagnosticNode});
-      }
-    }
-    if (type == null) {
-      if (Elements.isUnresolved(element)) {
-        type = const DynamicType();
-      } else {
-        type = element.enclosingClass.rawType;
-      }
-    }
-    resolver.registry.setType(expression, type);
-    return element;
-  }
-
-  Element visitTypeAnnotation(TypeAnnotation node) {
-    assert(invariant(node, type == null));
-    // This is not really resolving a type-annotation, but the name of the
-    // constructor. Therefore we allow deferred types.
-    type = resolver.resolveTypeAnnotation(node,
-                                          malformedIsError: inConstContext,
-                                          deferredIsMalformed: false);
-    registry.registerRequiredType(type, resolver.enclosingElement);
-    return type.element;
-  }
-
-  Element visitSend(Send node) {
-    Element element = visit(node.receiver);
-    assert(invariant(node.receiver, element != null,
-        message: 'No element return for $node.receiver.'));
-    if (Elements.isUnresolved(element)) return element;
-    Identifier name = node.selector.asIdentifier();
-    if (name == null) internalError(node.selector, 'unexpected node');
-
-    if (element.isClass) {
-      ClassElement cls = element;
-      cls.ensureResolved(compiler);
-      return resolveConstructor(cls, name, name.source);
-    } else if (element.isPrefix) {
-      PrefixElement prefix = element;
-      element = prefix.lookupLocalMember(name.source);
-      element = Elements.unwrap(element, compiler, node);
-      if (element == null) {
-        return failOrReturnErroneousElement(
-            resolver.enclosingElement, name,
-            name.source,
-            MessageKind.CANNOT_RESOLVE,
-            {'name': name});
-      } else if (!element.isClass) {
-        error(node, MessageKind.NOT_A_TYPE, {'node': name});
-      }
-    } else {
-      internalError(node.receiver, 'unexpected element $element');
-    }
-    return element;
-  }
-
-  Element visitIdentifier(Identifier node) {
-    String name = node.source;
-    Element element = resolver.reportLookupErrorIfAny(
-        lookupInScope(compiler, node, resolver.scope, name), node, name);
-    registry.useElement(node, element);
-    // TODO(johnniwinther): Change errors to warnings, cf. 11.11.1.
-    if (element == null) {
-      return failOrReturnErroneousElement(resolver.enclosingElement, node, name,
-                                          MessageKind.CANNOT_RESOLVE,
-                                          {'name': name});
-    } else if (element.isErroneous) {
-      return element;
-    } else if (element.isTypedef) {
-      error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
-            {'typedefName': name});
-    } else if (element.isTypeVariable) {
-      error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
-            {'typeVariableName': name});
-    } else if (!element.isClass && !element.isPrefix) {
-      error(node, MessageKind.NOT_A_TYPE, {'node': name});
-    }
-    return element;
-  }
-
-  /// Assumed to be called by [resolveRedirectingFactory].
-  Element visitRedirectingFactoryBody(RedirectingFactoryBody node) {
-    Node constructorReference = node.constructorReference;
-    return finishConstructorReference(visit(constructorReference),
-        constructorReference, node);
-  }
-}
-
-/// Looks up [name] in [scope] and unwraps the result.
-Element lookupInScope(Compiler compiler, Node node,
-                      Scope scope, String name) {
-  return Elements.unwrap(scope.lookup(name), compiler, node);
-}
-
-TreeElements _ensureTreeElements(AnalyzableElementX element) {
-  if (element._treeElements == null) {
-    element._treeElements = new TreeElementMapping(element);
-  }
-  return element._treeElements;
-}
-
-abstract class AnalyzableElementX implements AnalyzableElement {
-  TreeElements _treeElements;
-
-  bool get hasTreeElements => _treeElements != null;
-
-  TreeElements get treeElements {
-    assert(invariant(this, _treeElements !=null,
-        message: "TreeElements have not been computed for $this."));
-    return _treeElements;
-  }
-
-  void reuseElement() {
-    _treeElements = null;
-  }
-}
-
-/// The result of resolving a node.
-abstract class ResolutionResult {
-  Element get element;
-}
-
-/// The result for the resolution of a node that points to an [Element].
-class ElementResult implements ResolutionResult {
-  final Element element;
-
-  // TODO(johnniwinther): Remove this factory constructor when `null` is never
-  // passed as an element result.
-  factory ElementResult(Element element) {
-    return element != null ? new ElementResult.internal(element) : null;
-  }
-
-  ElementResult.internal(this.element);
-
-  String toString() => 'ElementResult($element)';
-}
-
-/// The result for the resolution of a node that points to an [DartType].
-class TypeResult implements ResolutionResult {
-  final DartType type;
-
-  TypeResult(this.type) {
-    assert(type != null);
-  }
-
-  Element get element => type.element;
-
-  String toString() => 'TypeResult($type)';
-}
-
-/// The result for the resolution of the `assert` method.
-class AssertResult implements ResolutionResult {
-  const AssertResult();
-
-  Element get element => null;
-
-  String toString() => 'AssertResult()';
-}