anchor.diff:      void addUnit(ImportSet importSet) {
         if (importSet.unit != null) return;
         var unit = new OutputUnit(false, '$counter',
  -          importSet._imports.map((i) => i.declaration).toSet());
  +          importSet._collectImports().map((i) => i.declaration).toSet());
         counter++;
         importSet.unit = unit;
         _allOutputUnits.add(unit);
  
positive.code:   Map<ImportEntity, _DeferredImport> _importIndex = {};
  
    /// The canonical instance representing the empty import set.
    ImportSet _emptySet = new ImportSet();
  
    /// The import set representing the main output unit, which happens to be
    /// implemented as an empty set in our algorithm.
  
negative.code: 
    /// Get the import set that includes the union of [a] and [b].
    ImportSet union(ImportSet a, ImportSet b) {
      if (a == null || a.isEmpty) return b;
      if (b == null || b.isEmpty) return a;
  
      // Create the union by merging the imports in canonical order. The sets are
      // basically lists linked by the `_previous` field in reverse order. We do a
      // merge-like scan 'backwards' removing the biggest element until we hit an
      // empty set or a common prefix, and the add the 'merge-sorted' elements
      // back onto the prefix.
      ImportSet result;
      // 'removed' imports in decreasing canonical order.
      List<_DeferredImport> imports = [];
  
      while (true) {
        if (a.isEmpty) {
          result = b;
          break;
        }
        if (b.isEmpty || identical(a, b)) {
          result = a;
          break;
        }
        if (a._import.index > b._import.index) {
          imports.add(a._import);
          a = a._previous;
        } else if (b._import.index > a._import.index) {
          imports.add(b._import);
          b = b._previous;
        } else {
          assert(identical(a._import, b._import));
          imports.add(a._import);
          a = a._previous;
          b = b._previous;
        }
      }
      while (imports.isNotEmpty) {
        result = result._add(imports.removeLast());
      }
      return result;
    }
  
  