anchor.diff:        new Map<Element, Element>();
   
     /**
  -   * Maps a name to elements in the universe that have that name.
  -   */
  -  final Map<SourceString, Set<Element>> methodCache =
  -      new Map<SourceString, Set<Element>>();
  -
  -  /**
      * Maps an element to the number of times this type inferrer
      * analyzed it.
      */
  
positive.code:    * [selector]. If [f] returns false, aborts the iteration.
     */
    void iterateOverElements(Selector selector, bool f(Element element)) {
      SourceString name = selector.name;
  
      // The following is already computed by the resolver, but it does
      // not save it yet.
      Set<Element> methods = methodCache[name];
      if (methods == null) {
        memberWatch.start();
        methods = new Set<Element>();
        void add(element) {
          if (!element.isInstanceMember()) return;
          if (element.isAbstract(compiler)) return;
          if (!compiler.enqueuer.resolution.isProcessed(element)) return;
          methods.add(element.implementation);
        }
        for (ClassElement cls in compiler.enqueuer.resolution.seenClasses) {
          var element = cls.lookupLocalMember(name);
          if (element != null) {
            if (element.isAbstractField()) {
              if (element.getter != null) add(element.getter);
              if (element.setter != null) add(element.setter);
            } else {
              add(element);
            }
          }
        }
        methodCache[name] = methods;
        memberWatch.stop();
      }
  
      for (Element element in methods) {
        if (selector.appliesUnnamed(element, compiler)) {
          if (!f(element)) return;
        }
      }
    }
  
  
negative.code: 
    final Compiler compiler;
  
    // Times the computation of re-analysis of methods.
    final Stopwatch recomputeWatch = new Stopwatch();
    // Number of re-analysis.
  