Split resolution/members.dart into several parts.

pkg/compiler/lib/src/resolution/resolution_common.dart

-// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2015, 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);
-
-  SendStructure getSendStructure(Send send);
-
-  // 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;
-  Maplet<Send, SendStructure> _sendStructureMap;
-
-  /// 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) {
-    // 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);
-
-  SendStructure getSendStructure(Send send) {
-    if (_sendStructureMap == null) return null;
-    return _sendStructureMap[send];
-  }
-
-  void setSendStructure(Send send, SendStructure sendStructure) {
-    if (_sendStructureMap == null) {
-      _sendStructureMap = new Maplet<Send, SendStructure>();
-    }
-    _sendStructureMap[send] = sendStructure;
-  }
-
-  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.isErroneous(element)) return null;
@@ skipping 933 matching lines @@
     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});
-        target = new ErroneousFieldElementX(
-            selector.asIdentifier(), constructor.enclosingClass);
-      } else if (target.kind != ElementKind.FIELD) {
-        error(selector, MessageKind.NOT_A_FIELD, {'fieldName': name});
-        target = new ErroneousFieldElementX(
-            selector.asIdentifier(), constructor.enclosingClass);
-      } 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.name);
-
-    final bool isImplicitSuperCall = false;
-    final String className = lookupTarget.name;
-    verifyThatConstructorMatchesCall(constructor,
-                                     calledConstructor,
-                                     selector.callStructure,
-                                     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);
-
-      final bool isSuperCall = true;
-      ClassElement lookupTarget = getSuperOrThisLookupTarget(constructor,
-                                                             isSuperCall,
-                                                             functionNode);
-      Selector constructorSelector = new Selector.callDefaultConstructor();
-      Element calledConstructor = lookupTarget.lookupConstructor(
-          constructorSelector.name);
-
-      final String className = lookupTarget.name;
-      final bool isImplicitSuperCall = true;
-      verifyThatConstructorMatchesCall(constructor,
-                                       calledConstructor,
-                                       CallStructure.NO_ARGS,
-                                       isImplicitSuperCall,
-                                       functionNode,
-                                       className,
-                                       constructorSelector);
-      registry.registerImplicitSuperCall(calledConstructor);
-      registry.registerStaticUse(calledConstructor);
-    }
-  }
-
-  void verifyThatConstructorMatchesCall(
-      FunctionElement caller,
-      ConstructorElementX lookedupConstructor,
-      CallStructure 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.signatureApplies(lookedupConstructor)) {
-        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.
-   */
-  ConstructorElement resolveInitializers(ConstructorElementX 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;
-    }
-    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);
-          } else {
-            constructor.isRedirectingGenerative = true;
-          }
-          // 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;
   }
@@ skipping 13 matching lines @@
 
   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) {
-        registry.registerThrowRuntimeError();
-        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) {
-      if (element is ErroneousElement) {
-        type = reportFailureAndCreateType(
-            element.messageKind, element.messageArguments,
-            erroneousElement: element);
-      } else {
-        type = const DynamicType();
-      }
-    } 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 &&
-            !Elements.hasAccessToTypeVariables(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.
@@ skipping 37 matching lines @@
 
   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;
-
-  /// Whether we are in a context where `this` is accessible (this will be false
-  /// in static contexts, factory methods, and field initializers).
-  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 reportAndCreateErroneousElement(
-      Node node,
-      String name,
-      MessageKind kind,
-      Map arguments,
-      {bool isError: false}) {
-    if (isError) {
-      compiler.reportError(node, kind, arguments);
-    } else {
-      compiler.reportWarning(node, kind, arguments);
-    }
-    // TODO(ahe): Use [allowedCategory] to synthesize a more precise subclass
-    // of [ErroneousElementX]. For example, [ErroneousFieldElementX],
-    // [ErroneousConstructorElementX], etc.
-    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) {
-          // We report an error within initializers because `this` is implicitly
-          // accessed when unqualified identifiers are not resolved.  For
-          // details, see section 16.14.3 of the spec (2nd edition):
-          //   An unqualified invocation `i` of the form `id(a1, ...)`
-          //   ...
-          //   If `i` does not occur inside a top level or static function, `i`
-          //   is equivalent to `this.id(a1 , ...)`.
-          bool inInitializer = enclosingElement.isGenerativeConstructor ||
-              (enclosingElement.isInstanceMember && enclosingElement.isField);
-          MessageKind kind;
-          Map arguments = {'name': name};
-          if (inInitializer) {
-            kind = MessageKind.CANNOT_RESOLVE_IN_INITIALIZER;
-          } else if (name == 'await') {
-            var functionName = enclosingElement.name;
-            if (functionName == '') {
-              kind = MessageKind.CANNOT_RESOLVE_AWAIT_IN_CLOSURE;
-            } else {
-              kind = MessageKind.CANNOT_RESOLVE_AWAIT;
-              arguments['functionName'] = functionName;
-            }
-          } else {
-            kind = MessageKind.CANNOT_RESOLVE;
-          }
-          element = reportAndCreateErroneousElement(node, name, kind,
-              arguments, isError: inInitializer);
-          registry.registerThrowNoSuchMethod();
-        }
-      } else if (element.isErroneous) {
-        // Use the erroneous element.
-      } else {
-        if ((element.kind.category & allowedCategory) == 0) {
-          element = reportAndCreateErroneousElement(
-              node, name, MessageKind.GENERIC,
-              // TODO(ahe): Improve error message. Need UX input.
-              {'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();
-    }
-  }
-
-  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.name);
-    }
-    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].
-      List<Element> optionals = functionParameters.optionalParameters;
-      if (!optionals.isEmpty && element == optionals.first) {
-        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(
-          (ParameterElementX parameter) {
-        parameter.constant =
-            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);
-    ResolverTask.processAsyncMarker(compiler, function, registry);
-    function.functionSignatureCache = SignatureResolver.analyze(
-        compiler,
-        node.parameters,
-        node.returnType,
-        function,
-        registry,
-        createRealParameters: true,
-        isFunctionExpression: !inFunctionDeclaration);
-    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) {
-        SendStructure sendStructure = const AssertStructure();
-        if (selector.argumentCount != 1) {
-          error(node.selector,
-                MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
-                {'argumentCount': selector.argumentCount});
-          sendStructure = const InvalidAssertStructure();
-        } else if (selector.namedArgumentCount != 0) {
-          error(node.selector,
-                MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
-                {'argumentCount': selector.namedArgumentCount});
-          sendStructure = const InvalidAssertStructure();
-        }
-        registry.registerAssert(node);
-        registry.registerSendStructure(node, sendStructure);
-        return const AssertResult();
-      }
-
-      return node.selector.accept(this);
-    }
-
-    var oldCategory = allowedCategory;
-    allowedCategory |= ElementCategory.PREFIX | ElementCategory.SUPER;
-
-    bool oldSendIsMemberAccess = sendIsMemberAccess;
-    int oldAllowedCategory = allowedCategory;
-
-    // Conditional sends like `e?.foo` treat the receiver as an expression.  So
-    // `C?.foo` needs to be treated like `(C).foo`, not like C.foo. Prefixes and
-    // super are not allowed on their own in that context.
-    if (node.isConditional) {
-      sendIsMemberAccess = false;
-      allowedCategory =
-          ElementCategory.VARIABLE |
-          ElementCategory.FUNCTION |
-          ElementCategory.IMPLIES_TYPE;
-    }
-    ResolutionResult resolvedReceiver = visit(node.receiver);
-    if (node.isConditional) {
-      sendIsMemberAccess = oldSendIsMemberAccess;
-      allowedCategory = oldAllowedCategory;
-    }
-
-    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"});
-      return null;
-    } else if (node.isSuperCall) {
-      if (node.isOperator) {
-        if (isUserDefinableOperator(name)) {
-          name = selector.name;
-        } else {
-          error(node.selector, MessageKind.ILLEGAL_SUPER_SEND, {'name': name});
-          return null;
-        }
-      }
-      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"});
-        return null;
-      }
-      // TODO(johnniwinther): Ensure correct behavior if currentClass is a
-      // patch.
-      target = currentClass.lookupSuperByName(selector.memberName);
-      // [target] may be null which means invoking noSuchMethod on
-      // super.
-      if (target == null) {
-        target = reportAndCreateErroneousElement(
-            node, name, MessageKind.NO_SUCH_SUPER_MEMBER,
-            {'className': currentClass.name, '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(reportAndCreateErroneousElement(
-            node, name, kind,
-            {'className': receiverClass.name, 'memberName': name}));
-      } else if (isPrivateName(name) &&
-                 target.library != enclosingElement.library) {
-        registry.registerThrowNoSuchMethod();
-        return new ElementResult(reportAndCreateErroneousElement(
-            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(reportAndCreateErroneousElement(
-            node, name, MessageKind.NO_SUCH_LIBRARY_MEMBER,
-            {'libraryName': prefix.name, 'memberName': name}));
-      } else if (target.isAmbiguous) {
-        registry.registerThrowNoSuchMethod();
-        AmbiguousElement ambiguous = target;
-        target = reportAndCreateErroneousElement(
-            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, '??') ||
-          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;
-  }
-
-  void registerTypeLiteralAccess(Send node, Element target) {
-    // 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);
-
-    if (!target.isTypeVariable) {
-      // Don't try to make constants of calls and assignments to type literals.
-      if (!node.isCall && node.asSendSet() == null) {
-        analyzeConstantDeferred(node, enforceConst: false);
-      } else {
-        // The node itself is not a constant but we register the selector (the
-        // identifier that refers to the class/typedef) as a constant.
-        if (node.receiver != null) {
-          // This is a hack for the case of prefix.Type, we need to store
-          // the element on the selector, so [analyzeConstant] can build
-          // the type literal from the selector.
-          registry.useElement(node.selector, target);
-        }
-        analyzeConstantDeferred(node.selector, enforceConst: false);
-      }
-    }
-  }
-
-  /// Check that access to `super` is currently allowed.
-  bool checkSuperAccess(Node node) {
-    if (!inInstanceContext) {
-      compiler.reportError(node, MessageKind.NO_SUPER_AVAILABLE);
-      return false;
-    }
-    if (currentClass.supertype == null) {
-      // This is just to guard against internal errors, so no need
-      // for a real error message.
-      compiler.reportError(node, MessageKind.GENERIC,
-            {'text': "Object has no superclass"});
-      return false;
-    }
-    registry.registerSuperUse(node);
-    return true;
-  }
-
-  /// Compute the [AccessSemantics] corresponding to a super access of [target].
-  AccessSemantics computeSuperAccess(Spannable node, Element target) {
-    if (target.isErroneous) {
-      return new StaticAccess.unresolvedSuper(target);
-    } else if (target.isGetter) {
-      return new StaticAccess.superGetter(target);
-    } else if (target.isSetter) {
-      return new StaticAccess.superSetter(target);
-    } else if (target.isField) {
-      return new StaticAccess.superField(target);
-    } else {
-      assert(invariant(node, target.isFunction,
-          message: "Unexpected super target '$target'."));
-      return new StaticAccess.superMethod(target);
-    }
-  }
-
-  AccessSemantics computeSuperSemantics(Spannable node,
-                                        Selector selector,
-                                        {Name alternateName}) {
-    Name name = selector.memberName;
-    // TODO(johnniwinther): Ensure correct behavior if currentClass is a
-    // patch.
-    Element target = currentClass.lookupSuperByName(name);
-    // [target] may be null which means invoking noSuchMethod on super.
-    if (target == null) {
-      Element error = reportAndCreateErroneousElement(
-          node, name.text, MessageKind.NO_SUCH_SUPER_MEMBER,
-          {'className': currentClass.name, 'memberName': name});
-      if (alternateName != null) {
-        target = currentClass.lookupSuperByName(alternateName);
-      }
-      if (target == null) {
-        // If a setter wasn't resolved, use the [ErroneousElement].
-        target = error;
-      }
-      // We still need to register the invocation, because we might
-      // call [:super.noSuchMethod:] which calls [JSInvocationMirror._invokeOn].
-      registry.registerDynamicInvocation(selector);
-      registry.registerSuperNoSuchMethod();
-    }
-    return computeSuperAccess(node, target);
-  }
-
-  ResolutionResult visitExpression(Node node) {
-    bool oldSendIsMemberAccess = sendIsMemberAccess;
-    sendIsMemberAccess = false;
-    ResolutionResult result = visit(node);
-    sendIsMemberAccess = oldSendIsMemberAccess;
-    return result;
-  }
-
-  ResolutionResult handleIs(Send node) {
-    Node expression = node.receiver;
-    visitExpression(expression);
-
-    // TODO(johnniwinther): Use seen type tests to avoid registration of
-    // mutation/access to unpromoted variables.
-
-    Send notTypeNode = node.arguments.head.asSend();
-    DartType type;
-    SendStructure sendStructure;
-    if (notTypeNode != null) {
-      // `e is! T`.
-      Node typeNode = notTypeNode.receiver;
-      type = resolveTypeAnnotation(typeNode);
-      sendStructure = new IsNotStructure(type);
-    } else {
-      // `e is T`.
-      Node typeNode = node.arguments.head;
-      type = resolveTypeAnnotation(typeNode);
-      sendStructure = new IsStructure(type);
-    }
-    registry.registerIsCheck(type);
-    registry.registerSendStructure(node, sendStructure);
-    return null;
-  }
-
-  ResolutionResult handleAs(Send node) {
-    Node expression = node.receiver;
-    visitExpression(expression);
-
-    Node typeNode = node.arguments.head;
-    DartType type = resolveTypeAnnotation(typeNode);
-    registry.registerAsCheck(type);
-    registry.registerSendStructure(node, new AsStructure(type));
-    return null;
-  }
-
-  ResolutionResult handleUnresolvedUnary(Send node, String text) {
-    Node expression = node.receiver;
-    if (node.isSuperCall) {
-      checkSuperAccess(node);
-    } else {
-      visitExpression(expression);
-    }
-
-    registry.registerSendStructure(node, const InvalidUnaryStructure());
-    return null;
-  }
-
-  ResolutionResult handleUserDefinableUnary(Send node, UnaryOperator operator) {
-    Node expression = node.receiver;
-    Selector selector = operator.selector;
-    // TODO(johnniwinther): Remove this when all information goes through the
-    // [SendStructure].
-    registry.setSelector(node, selector);
-
-    AccessSemantics semantics;
-    if (node.isSuperCall) {
-      if (checkSuperAccess(node)) {
-        semantics = computeSuperSemantics(node, selector);
-        // TODO(johnniwinther): Add information to [AccessSemantics] about
-        // whether it is erroneous.
-        if (semantics.kind == AccessKind.SUPER_METHOD) {
-          registry.registerStaticUse(semantics.element.declaration);
-        }
-        // TODO(johnniwinther): Remove this when all information goes through
-        // the [SendStructure].
-        registry.useElement(node, semantics.element);
-      }
-    } else {
-      visitExpression(expression);
-      semantics = new DynamicAccess.dynamicProperty(expression);
-      registry.registerDynamicInvocation(selector);
-    }
-    if (semantics != null) {
-      // TODO(johnniwinther): Support invalid super access as an
-      // [AccessSemantics].
-      registry.registerSendStructure(node,
-          new UnaryStructure(semantics, operator));
-    }
-    return null;
-  }
-
-  ResolutionResult handleNot(Send node, UnaryOperator operator) {
-    assert(invariant(node, operator.kind == UnaryOperatorKind.NOT));
-
-    Node expression = node.receiver;
-    visitExpression(expression);
-    registry.registerSendStructure(node,
-        new NotStructure(new DynamicAccess.dynamicProperty(expression)));
-    return null;
-  }
-
-  ResolutionResult handleLogicalAnd(Send node) {
-    Node left = node.receiver;
-    Node right = node.arguments.head;
-    doInPromotionScope(left, () => visitExpression(left));
-    doInPromotionScope(right, () => visitExpression(right));
-    registry.registerSendStructure(node, const LogicalAndStructure());
-    return null;
-  }
-
-  ResolutionResult handleLogicalOr(Send node) {
-    Node left = node.receiver;
-    Node right = node.arguments.head;
-    visitExpression(left);
-    visitExpression(right);
-    registry.registerSendStructure(node, const LogicalOrStructure());
-    return null;
-  }
-
-  ResolutionResult handleIfNull(Send node) {
-    Node left = node.receiver;
-    Node right = node.arguments.head;
-    visitExpression(left);
-    visitExpression(right);
-    registry.registerSendStructure(node, const IfNullStructure());
-    return null;
-  }
-
-  ResolutionResult handleUnresolvedBinary(Send node, String text) {
-    Node left = node.receiver;
-    Node right = node.arguments.head;
-    if (node.isSuperCall) {
-      checkSuperAccess(node);
-    } else {
-      visitExpression(left);
-    }
-    visitExpression(right);
-    registry.registerSendStructure(node, const InvalidBinaryStructure());
-    return null;
-  }
-
-  ResolutionResult handleUserDefinableBinary(Send node,
-                                             BinaryOperator operator) {
-    Node left = node.receiver;
-    Node right = node.arguments.head;
-    AccessSemantics semantics;
-    Selector selector;
-    if (operator.kind == BinaryOperatorKind.INDEX) {
-      selector = new Selector.index();
-    } else {
-      selector = new Selector.binaryOperator(operator.selectorName);
-    }
-    // TODO(johnniwinther): Remove this when all information goes through the
-    // [SendStructure].
-    registry.setSelector(node, selector);
-
-    if (node.isSuperCall) {
-      if (checkSuperAccess(node)) {
-        semantics = computeSuperSemantics(node, selector);
-        // TODO(johnniwinther): Add information to [AccessSemantics] about
-        // whether it is erroneous.
-        if (semantics.kind == AccessKind.SUPER_METHOD) {
-          registry.registerStaticUse(semantics.element.declaration);
-        }
-        // TODO(johnniwinther): Remove this when all information goes through
-        // the [SendStructure].
-        registry.useElement(node, semantics.element);
-
-      }
-    } else {
-      visitExpression(left);
-      registry.registerDynamicInvocation(selector);
-      semantics = new DynamicAccess.dynamicProperty(left);
-    }
-    visitExpression(right);
-
-    if (semantics != null) {
-      // TODO(johnniwinther): Support invalid super access as an
-      // [AccessSemantics].
-      SendStructure sendStructure;
-      switch (operator.kind) {
-        case BinaryOperatorKind.EQ:
-          sendStructure = new EqualsStructure(semantics);
-          break;
-        case BinaryOperatorKind.NOT_EQ:
-          sendStructure = new NotEqualsStructure(semantics);
-          break;
-        case BinaryOperatorKind.INDEX:
-          sendStructure = new IndexStructure(semantics);
-          break;
-        case BinaryOperatorKind.ADD:
-        case BinaryOperatorKind.SUB:
-        case BinaryOperatorKind.MUL:
-        case BinaryOperatorKind.DIV:
-        case BinaryOperatorKind.IDIV:
-        case BinaryOperatorKind.MOD:
-        case BinaryOperatorKind.SHL:
-        case BinaryOperatorKind.SHR:
-        case BinaryOperatorKind.GTEQ:
-        case BinaryOperatorKind.GT:
-        case BinaryOperatorKind.LTEQ:
-        case BinaryOperatorKind.LT:
-        case BinaryOperatorKind.AND:
-        case BinaryOperatorKind.OR:
-        case BinaryOperatorKind.XOR:
-          sendStructure = new BinaryStructure(semantics, operator);
-          break;
-        case BinaryOperatorKind.LOGICAL_AND:
-        case BinaryOperatorKind.LOGICAL_OR:
-        case BinaryOperatorKind.IF_NULL:
-          internalError(node, "Unexpected binary operator '${operator}'.");
-          break;
-      }
-      registry.registerSendStructure(node, sendStructure);
-    }
-    return null;
-  }
-
-  ResolutionResult visitSend(Send node) {
-    if (node.isOperator) {
-      String operatorText = node.selector.asOperator().source;
-      if (operatorText == 'is') {
-        return handleIs(node);
-      } else if (operatorText  == 'as') {
-        return handleAs(node);
-      } else if (node.arguments.isEmpty) {
-        UnaryOperator operator = UnaryOperator.parse(operatorText);
-        if (operator == null) {
-          return handleUnresolvedUnary(node, operatorText);
-        } else {
-          switch (operator.kind) {
-            case UnaryOperatorKind.NOT:
-              return handleNot(node, operator);
-            case UnaryOperatorKind.COMPLEMENT:
-            case UnaryOperatorKind.NEGATE:
-              assert(invariant(node, operator.isUserDefinable,
-                  message: "Unexpected unary operator '${operator}'."));
-              return handleUserDefinableUnary(node, operator);
-          }
-          return handleUserDefinableUnary(node, operator);
-        }
-      } else {
-        BinaryOperator operator = BinaryOperator.parse(operatorText);
-        if (operator == null) {
-          return handleUnresolvedBinary(node, operatorText);
-        } else {
-          switch (operator.kind) {
-            case BinaryOperatorKind.LOGICAL_AND:
-              return handleLogicalAnd(node);
-            case BinaryOperatorKind.LOGICAL_OR:
-              return handleLogicalOr(node);
-            case BinaryOperatorKind.IF_NULL:
-              return handleIfNull(node);
-            case BinaryOperatorKind.EQ:
-            case BinaryOperatorKind.NOT_EQ:
-            case BinaryOperatorKind.INDEX:
-            case BinaryOperatorKind.ADD:
-            case BinaryOperatorKind.SUB:
-            case BinaryOperatorKind.MUL:
-            case BinaryOperatorKind.DIV:
-            case BinaryOperatorKind.IDIV:
-            case BinaryOperatorKind.MOD:
-            case BinaryOperatorKind.SHL:
-            case BinaryOperatorKind.SHR:
-            case BinaryOperatorKind.GTEQ:
-            case BinaryOperatorKind.GT:
-            case BinaryOperatorKind.LTEQ:
-            case BinaryOperatorKind.LT:
-            case BinaryOperatorKind.AND:
-            case BinaryOperatorKind.OR:
-            case BinaryOperatorKind.XOR:
-              return handleUserDefinableBinary(node, operator);
-          }
-        }
-      }
-    }
-
-    bool oldSendIsMemberAccess = sendIsMemberAccess;
-    sendIsMemberAccess = node.isPropertyAccess || node.isCall;
-
-    ResolutionResult 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 (target != null) {
-      if (target.isErroneous) {
-        registry.registerThrowNoSuchMethod();
-      } else if (target.isAbstractField) {
-        AbstractFieldElement field = target;
-        target = field.getter;
-        if (target == null) {
-          if (!inInstanceContext || field.isTopLevel || field.isStatic) {
-            registry.registerThrowNoSuchMethod();
-            target = reportAndCreateErroneousElement(node.selector, field.name,
-                MessageKind.CANNOT_RESOLVE_GETTER, const {});
-          }
-        }
-      } else if (target.isTypeVariable) {
-        ClassElement cls = target.enclosingClass;
-        assert(enclosingElement.enclosingClass == cls);
-        if (!Elements.hasAccessToTypeVariables(enclosingElement)) {
-          compiler.reportError(node,
-              MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
-              {'typeVariableName': node.selector});
-        }
-        registry.registerClassUsingVariableExpression(cls);
-        registry.registerTypeVariableExpression();
-        registerTypeLiteralAccess(node, target);
-      } else if (target.impliesType && (!sendIsMemberAccess || node.isCall)) {
-        registerTypeLiteralAccess(node, target);
-      }
-      if (isPotentiallyMutableTarget(target)) {
-        if (enclosingElement != target.enclosingElement) {
-          for (Node scope in promotionScope) {
-            registry.setAccessedByClosureIn(scope, target, node);
-          }
-        }
-      }
-    }
-
-    bool resolvedArguments = false;
-    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_BUILTIN') {
-          registry.registerJsBuiltinCall(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) {
-          if (!inInstanceContext || getter.isTopLevel || getter.isStatic) {
-            setter = reportAndCreateErroneousElement(node.selector, field.name,
-                MessageKind.CANNOT_RESOLVE_SETTER, const {});
-            registry.registerThrowNoSuchMethod();
-          }
-        }
-        if (isComplex && getter == null && !inInstanceContext) {
-          getter = reportAndCreateErroneousElement(node.selector, field.name,
-              MessageKind.CANNOT_RESOLVE_GETTER, const {});
-          registry.registerThrowNoSuchMethod();
-        }
-      } else if (target.impliesType) {
-        if (node.isIfNullAssignment) {
-          setter = reportAndCreateErroneousElement(node.selector, target.name,
-              MessageKind.IF_NULL_ASSIGNING_TYPE, const {});
-          // In this case, no assignment happens, the rest of the compiler can
-          // treat the expression `C ??= e` as if it's just reading `C`.
-        } else {
-          setter = reportAndCreateErroneousElement(node.selector, target.name,
-              MessageKind.ASSIGNING_TYPE, const {});
-          registry.registerThrowNoSuchMethod();
-        }
-        registerTypeLiteralAccess(node, target);
-      } else if (target.isFinal || target.isConst) {
-        if (Elements.isStaticOrTopLevelField(target) || target.isLocal) {
-          setter = reportAndCreateErroneousElement(
-              node.selector, target.name, MessageKind.CANNOT_RESOLVE_SETTER,
-              const {});
-        } else if (node.isSuperCall) {
-          setter = reportAndCreateErroneousElement(
-              node.selector, target.name, MessageKind.SETTER_NOT_FOUND_IN_SUPER,
-              {'name': target.name, 'className': currentClass.name});
-          registry.registerSuperNoSuchMethod();
-        } else {
-          // For instance fields we don't report a warning here because the type
-          // checker will detect this as well and report a better error message
-          // with the context of the containing class.
-        }
-        registry.registerThrowNoSuchMethod();
-      } else if (target.isFunction && target.name != '[]=') {
-        assert(!target.isSetter);
-        if (Elements.isStaticOrTopLevelFunction(target) || target.isLocal) {
-          setter = reportAndCreateErroneousElement(
-              node.selector, target.name, MessageKind.ASSIGNING_METHOD,
-              const {});
-        } else if (node.isSuperCall) {
-          setter = reportAndCreateErroneousElement(
-              node.selector, target.name, MessageKind.ASSIGNING_METHOD_IN_SUPER,
-              {'name': target.name,
-               'superclassName': target.enclosingElement.name});
-          registry.registerSuperNoSuchMethod();
-        } else {
-          // For instance methods we don't report a warning here because the
-          // type checker will detect this as well and report a better error
-          // message with the context of the containing class.
-        }
-        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.lookupSuperByName(getterSelector.memberName);
-        if (getter == null) {
-          target = reportAndCreateErroneousElement(
-              node, selector.name, MessageKind.NO_SUCH_SUPER_MEMBER,
-              {'className': currentClass.name, '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});
-    }
-    analyzeConstantDeferred(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) {
-      if (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);
-      } else if (!node.isArrowBody && currentAsyncMarker.isYielding) {
-        compiler.reportError(
-            node,
-            MessageKind.RETURN_IN_GENERATOR,
-            {'modifier': currentAsyncMarker});
-      }
-    }
-    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;
-
-    Node constructorReference = node.constructorReference;
-    if (constructorReference is Send) {
-      constructor.redirectionDeferredPrefix =
-          compiler.deferredLoadTask.deferredPrefixElement(constructorReference,
-                                                          registry.mapping);
-    }
-
-    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);
-      }
-    }
-
-    // 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;
-    var oldCategory = allowedCategory;
-    allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
-        | ElementCategory.IMPLIES_TYPE;
-    visit(node.expression);
-    allowedCategory = oldCategory;
-    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;
-    if (cls.isEnumClass && currentClass != cls) {
-      compiler.reportError(node,
-                           MessageKind.CANNOT_INSTANTIATE_ENUM,
-                           {'enumName': cls.name});
-    }
-
-    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.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.getType(compiler.coreTypes);
-          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) {
-      analyzeConstantDeferred(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, {enforceConst: true}) {
-    ConstantExpression constant =
-        compiler.resolver.constantCompiler.compileNode(
-            node, registry.mapping, enforceConst: enforceConst);
-
-    if (constant == null) {
-      assert(invariant(node, compiler.compilationFailed));
-      return;
-    }
-
-    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);
-      }
-    }
-  }
-
-  void analyzeConstantDeferred(Node node, {bool enforceConst: true}) {
-    addDeferredAction(enclosingElement, () {
-      analyzeConstant(node, enforceConst: enforceConst);
-    });
-  }
-
-  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) {
-      analyzeConstantDeferred(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);
-  }
-
-  visitAsyncForIn(AsyncForIn node) {
-    registry.registerAsyncForIn(node);
-    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);
-    visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
-    visitLoopBodyIn(node, node.body, blockScope);
-  }
-
-  visitSyncForIn(SyncForIn node) {
-    registry.registerSyncForIn(node);
-    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);
-    visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
-    visitLoopBodyIn(node, node.body, blockScope);
-  }
-
-  visitForInDeclaredIdentifierIn(Node declaration, ForIn node,
-                                 Scope blockScope) {
-    LibraryElement library = enclosingElement.library;
-
-    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);
-    }
-  }
-
-  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) {
-    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.registerMapLiteral(node, mapType, node.isConst);
-    registry.registerRequiredType(mapType, enclosingElement);
-    node.visitChildren(this);
-    if (node.isConst) {
-      analyzeConstantDeferred(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) {
-    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) {
-          analyzeConstantDeferred(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 BaseDartTypeVisitor {
-  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) {
-    if (element == null) {
-      throw compiler.internalError(node, 'element is null');
-    }
-    if (element.resolutionState != STATE_STARTED) {
-      throw compiler.internalError(element,
-          '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);
-      if (superMember.isErroneous) {
-        compiler.elementsWithCompileTimeErrors.add(constructor);
-      }
-      element.setDefaultConstructor(constructor, compiler);
-    }
-    return element.computeType(compiler);
-  }
-
-  @override
-  DartType visitEnum(Enum node) {
-    if (element == null) {
-      throw compiler.internalError(node, 'element is null');
-    }
-    if (element.resolutionState != STATE_STARTED) {
-      throw compiler.internalError(element,
-          'cyclic resolution of class $element');
-    }
-
-    InterfaceType enumType = element.computeType(compiler);
-    element.supertype = compiler.objectClass.computeType(compiler);
-    element.interfaces = const Link<DartType>();
-    calculateAllSupertypes(element);
-
-    if (node.names.nodes.isEmpty) {
-      compiler.reportError(node,
-                           MessageKind.EMPTY_ENUM_DECLARATION,
-                           {'enumName': element.name});
-    }
-
-    EnumCreator creator = new EnumCreator(compiler, element);
-    creator.createMembers();
-    return enumType;
-  }
-
-  /// 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});
-    } else if (mixinType.isEnumType) {
-      compiler.reportError(mixinNode, MessageKind.CANNOT_MIXIN_ENUM,
-          {'className': element.name, 'enumType': mixinType});
-    }
-    return mixinType;
-  }
-
-  DartType visitNamedMixinApplication(NamedMixinApplication node) {
-    if (element == null) {
-      throw compiler.internalError(node, 'element is null');
-    }
-    if (element.resolutionState != STATE_STARTED) {
-      throw compiler.internalError(element,
-          '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.
-    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.notForDefault(
-        target.name, target, enclosing);
-  }
-
-  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 (supertype.isMalformed) {
-        compiler.reportError(superclass, MessageKind.CANNOT_EXTEND_MALFORMED,
-            {'className': element.name, 'malformedType': supertype});
-        return objectType;
-      } else if (supertype.isEnumType) {
-        compiler.reportError(superclass, MessageKind.CANNOT_EXTEND_ENUM,
-            {'className': element.name, 'enumType': supertype});
-        return objectType;
-      } else if (!supertype.isInterfaceType) {
-        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 (interfaceType.isMalformed) {
-          compiler.reportError(superclass,
-              MessageKind.CANNOT_IMPLEMENT_MALFORMED,
-              {'className': element.name, 'malformedType': interfaceType});
-        } else if (interfaceType.isEnumType) {
-          compiler.reportError(superclass,
-              MessageKind.CANNOT_IMPLEMENT_ENUM,
-              {'className': element.name, 'enumType': interfaceType});
-        } else if (!interfaceType.isInterfaceType) {
-          // 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 visitEnum(Enum node) {
-    loadSupertype(compiler.objectClass, node);
-  }
-
-  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);
-      LocalVariableElementX 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, () {
-          element.constant =
-              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';
-  }
-
-  ErroneousConstructorElementX failOrReturnErroneousConstructorElement(
-      Spannable diagnosticNode,
-      Element enclosing,
-      String name,
-      MessageKind kind,
-      Map arguments,
-      {bool isError: false,
-       bool missingConstructor: false}) {
-    if (missingConstructor) {
-      registry.registerThrowNoSuchMethod();
-    } else {
-      registry.registerThrowRuntimeError();
-    }
-    if (isError || inConstContext) {
-      compiler.reportError(diagnosticNode, kind, arguments);
-    } else {
-      compiler.reportWarning(diagnosticNode, kind, arguments);
-    }
-    return new ErroneousConstructorElementX(
-        kind, arguments, name, enclosing);
-  }
-
-  FunctionElement resolveConstructor(ClassElement cls,
-                                     Node diagnosticNode,
-                                     String constructorName) {
-    cls.ensureResolved(compiler);
-    Element result = cls.lookupConstructor(constructorName);
-    // TODO(johnniwinther): Use [Name] for lookup.
-    if (isPrivateName(constructorName) &&
-        resolver.enclosingElement.library != cls.library) {
-      result = null;
-    }
-    if (result == null) {
-      String fullConstructorName = Elements.constructorNameForDiagnostics(
-              cls.name,
-              constructorName);
-      return failOrReturnErroneousConstructorElement(
-          diagnosticNode,
-          cls, constructorName,
-          MessageKind.CANNOT_FIND_CONSTRUCTOR,
-          {'constructorName': fullConstructorName},
-          missingConstructor: true);
-    } 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 = failOrReturnErroneousConstructorElement(
-            diagnosticNode,
-            element, element.name,
-            MessageKind.NOT_A_TYPE, {'node': diagnosticNode});
-      }
-    } else if (element.isErroneous && element is! ErroneousElementX) {
-      // Parser error. The error has already been reported.
-      element = new ErroneousConstructorElementX(
-          MessageKind.NOT_A_TYPE, {'node': diagnosticNode},
-          element.name, element);
-      registry.registerThrowRuntimeError();
-    }
-
-    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 failOrReturnErroneousConstructorElement(
-            name,
-            resolver.enclosingElement, name.source,
-            MessageKind.CANNOT_RESOLVE, {'name': name});
-      } else if (!element.isClass) {
-        return failOrReturnErroneousConstructorElement(
-            name,
-            resolver.enclosingElement, name.source,
-            MessageKind.NOT_A_TYPE, {'node': name},
-            isError: true);
-      }
-    } 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 failOrReturnErroneousConstructorElement(
-          node,
-          resolver.enclosingElement, name,
-          MessageKind.CANNOT_RESOLVE,
-          {'name': name});
-    } else if (element.isErroneous) {
-      return element;
-    } else if (element.isTypedef) {
-      element = failOrReturnErroneousConstructorElement(
-          node,
-          resolver.enclosingElement, name,
-          MessageKind.CANNOT_INSTANTIATE_TYPEDEF, {'typedefName': name},
-          isError: true);
-    } else if (element.isTypeVariable) {
-      element = failOrReturnErroneousConstructorElement(
-          node,
-          resolver.enclosingElement, name,
-          MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
-          {'typeVariableName': name},
-          isError: true);
-    } else if (!element.isClass && !element.isPrefix) {
-      element = failOrReturnErroneousConstructorElement(
-          node,
-          resolver.enclosingElement, name,
-          MessageKind.NOT_A_TYPE, {'node': name},
-          isError: true);
-    }
-    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()';
-}