anchor.diff:      OutputUnit outputUnit = new OutputUnit();
       outputUnit.imports.add(prefix.deferredImport);
       _constantToOutputUnit[constant] = outputUnit;
  -  }
  -
  -  /// Mark that [import] is part of the [OutputputUnit] for [element].
  -  ///
  -  /// [element] can be either a [Constant] or an [Element].
  -  void _addImportToOutputUnitOfElement(Element element, Import import) {
  -    // Only one file should be loaded when the program starts, so make
  -    // sure that only one OutputUnit is created for [fakeMainImport].
  -    if (import == _fakeMainImport) {
  -      _elementToOutputUnit[element] = mainOutputUnit;
  -    }
  -    _elementToOutputUnit.putIfAbsent(element, () => new OutputUnit())
  -        .imports.add(import);
  -  }
  -
  -  /// Mark that [import] is part of the [OutputputUnit] for [constant].
  -  ///
  -  /// [constant] can be either a [Constant] or an [Element].
  -  void _addImportToOutputUnitOfConstant(Constant constant, Import import) {
  -    // Only one file should be loaded when the program starts, so make
  -    // sure that only one OutputUnit is created for [fakeMainImport].
  -    if (import == _fakeMainImport) {
  -      _constantToOutputUnit[constant] = mainOutputUnit;
  -    }
  -    _constantToOutputUnit.putIfAbsent(constant, () => new OutputUnit())
  -        .imports.add(import);
     }
   
     /// Answers whether [element] is explicitly deferred when referred to from
  
positive.code:       _importedDeferredBy = null;
        _constantsDeferredBy = null;
  
        // Find all the output units we have used.
        // Also generate a unique name for each OutputUnit.
        for (OutputUnit outputUnit in _elementToOutputUnit.values) {
          allOutputUnits.add(outputUnit);
        }
        for (OutputUnit outputUnit in _constantToOutputUnit.values) {
          allOutputUnits.add(outputUnit);
        }
  
        _assignNamesToOutputUnits(allOutputUnits);
      });
    }
  
negative.code:         _addMirrorElements();
        }
  
        // Build the OutputUnits using these two maps.
        Map<Element, OutputUnit> elementToOutputUnitBuilder =
            new Map<Element, OutputUnit>();
        Map<Constant, OutputUnit> constantToOutputUnitBuilder =
            new Map<Constant, OutputUnit>();
  
        // Reverse the mappings. For each element record an OutputUnit collecting
        // all deferred imports mapped to this element. Same for constants.
        for (Import import in _importedDeferredBy.keys) {
          for (Element element in _importedDeferredBy[import]) {
            // Only one file should be loaded when the program starts, so make
            // sure that only one OutputUnit is created for [fakeMainImport].
            if (import == _fakeMainImport) {
              elementToOutputUnitBuilder[element] = mainOutputUnit;
            } else {
              elementToOutputUnitBuilder
                  .putIfAbsent(element, () => new OutputUnit())
                  .imports.add(import);
            }
          }
          for (Constant constant in _constantsDeferredBy[import]) {
            // Only one file should be loaded when the program starts, so make
            // sure that only one OutputUnit is created for [fakeMainImport].
            if (import == _fakeMainImport) {
              constantToOutputUnitBuilder[constant] = mainOutputUnit;
            } else {
              constantToOutputUnitBuilder
                  .putIfAbsent(constant, () => new OutputUnit())
                  .imports.add(import);
            }
          }
        }
  
  