anchor.diff:  
     // Merge [deps], [_allIds]-aware to reduce gaps. `null` if the deps are
     // incompatible source/desc. Algorithm TBD.
  +  //
  +  // TODO: [_transitiveIncompatible] needs this to return `null` for empty list.
     PackageDep _mergeDeps(Iterable<PackageDep> deps);
   
     // Intersect [deps], return `null` if they aren't compatible (diff name, diff
  
positive.code:       //
        // we can add
        //
        // * a [0, 1) is incompatible with c [1, 2)
        var mergedMatching = _mergeDeps(incompatibilities
            .map((incompatibility) => _matching(incompatibility, fact.allowed)));
        if (mergedMatching == null ||
            !mergedMatching.constraint.allowsAll(fact.allowed.constraint)) {
          continue;
        }
  
        var mergedNonMatching = _intersectDeps(incompatibilities.map(
            (incompatibility) => _nonMatching(incompatibility, fact.allowed)));
        if (mergedNonMatching == null) continue;
        _forCurrent.add(new Incompatibility(fact.depender, mergedNonMatching,
            incompatibilities.toList()..add(fact)));
      }
    }
  
negative.code:         if (result != null) _replaceCurrent(result);
          return false;
        }
      }
    }
  
    bool _incompatibilityIntoDependencies(Incompatibility fact) {
      // Get all the incompatibilities with the same pair of packages as [fact].
      var ref1 = fact.dep1.toRef();
      var ref2 = fact.dep2.toRef();
      var siblings = _incompatibilities[ref1]
          .where((incompatibility) =>
              incompatibility.dep1.toRef() == ref2 ||
              incompatibility.dep2.toRef() == ref2)
          .toList()..add(fact);
  
      // If there are dependencies whose allowed constraints are covered entirely
      // by [siblings], we can probably create a new incompatibility for their
      // dependers. For example, if
      //
      // * a [0, 1) is incompatible with b [0, 2) (fact)
      // * a [1, 2) is incompatible with b [1, 3) (in siblings)
      // * c [0, 1) depends on a [0, 2) (dependency)
      //
      // we can add
      //
      // * c [0, 1) is incompatible with b [1, 3)
  
      for (var dependency in _dependenciesByAllowed[ref1]) {
        var incompatible = _transitiveIncompatible(dependency.allowed, siblings);
        if (incompatible == null) continue;
        _forCurrent.add(new Incompatibility(dependency.depender, incompatible,
            [dependency]..addAll(siblings)));
      }
  
      for (var dependency in _dependenciesByAllowed[ref2]) {
        var incompatible = _transitiveIncompatible(dependency.allowed, siblings);
        if (incompatible == null) continue;
        _forCurrent.add(new Incompatibility(dependency.depender, incompatible,
            [dependency]..addAll(siblings)));
      }
    }
  
  