anchor.diff:    /// Recursively traverses the graph of dependencies from [element], mapping
     /// deferred imports to each dependency it needs in the sets
     /// [_importedDeferredBy] and [_constantsDeferredBy].
  -  void _mapDependencies(Element element, Import import) {
  +  void _mapDependencies(Element element, Import import,
  +                        {isMirrorUsage: false}) {
       Set<Element> elements = _importedDeferredBy.putIfAbsent(import,
           () => new Set<Element>());
       Set<Constant> constants = _constantsDeferredBy.putIfAbsent(import,
           () => new Set<Constant>());
   
  -    if (elements.contains(element)) return;
  +    // Only process elements once, unless we are doing dependencies due to
  +    // mirrors, which are added in additional traversals.
  +    if (!isMirrorUsage && elements.contains(element)) return;
       // Anything used directly by main will be loaded from the start
       // We do not need to traverse it again.
       if (import != _fakeMainImport && _mainElements.contains(element)) return;
  
positive.code: 
      // This call can modify [_importedDeferredBy] and [_constantsDeferredBy].
      _collectAllElementsAndConstantsResolvedFrom(
          element, dependentElements, constants);
  
      LibraryElement library = element.library;
      for (Element dependency in dependentElements) {
  
negative.code:       ClassElement implementation =
            element.enclosingClass.implementation;
        _collectAllElementsAndConstantsResolvedFrom(
            implementation, elements, constants, isMirrorUsage);
      }
  
      // Other elements, in particular instance members, are ignored as
  