anchor.diff:    void _collectAllElementsAndConstantsResolvedFrom(
         Element element,
         Set<Element> elements,
  -      Set<Constant> constants) {
  +      Set<Constant> constants,
  +      isMirrorUsage) {
   
       /// Recursively add the constant and its dependencies to [constants].
       void addConstants(Constant constant) {
  
positive.code:     }
      if (element.isClass) {
        // If we see a class, add everything its live instance members refer
        // to.  Static members are not relevant.
        void addLiveInstanceMember(Element element) {
          if (!compiler.enqueuer.resolution.isLive(element)) return;
          if (!element.isInstanceMember) return;
          collectDependencies(element.implementation);
        }
        ClassElement cls = element.declaration;
  
negative.code:   /// 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,
                          {isMirrorUsage: false}) {
      Set<Element> elements = _importedDeferredBy.putIfAbsent(import,
          () => new Set<Element>());
      Set<Constant> constants = _constantsDeferredBy.putIfAbsent(import,
          () => new Set<Constant>());
  
      // 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;
  