anchor.diff:      return null;
     }
   
  +  void _dependencyIntoIncompatibilities(Dependency fact) {
  +    var byNonMatching = groupBy(
  +        _incompatibilities[fact.allowed.toRef()],
  +        (incompatibility) =>
  +            _nonMatching(incompatibility, fact.allowed).toRef());
  +    for (var incompatibilities in byNonMatching.values) {
  +      // If there are incompatibilities where one side covers a [fact.allowed]
  +      // and the other side has a non-empty intersection, we can create a new
  +      // incompatibility for [fact.depender]. For example, if
  +      //
  +      // * a [0, 1) depends on b [0, 2) (fact)
  +      // * b [0, 1) is incompatible with c [0, 2) (in incompatibilities)
  +      // * b [1, 2) is incompatible with c [1, 3) (in incompatibilities)
  +      //
  +      // 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)));
  +    }
  +  }
  +
     // Resolves [required] and [disallowed], which should refer to the same
     // package.
     //
  
positive.code:   Fact _requiredAndAllowed(Required required, Dependency dependency) {
      assert(required.dep.name == dependency.allowed.name);
  
      var intersection = _intersectDeps(required.dep, dependency.allowed);
      if (intersection == null) {
        // If there are no versions covered by both [dependency.allowed] and
        // [required], then this dependency can never be satisfied and the
  
negative.code:     // we can remove both [fact] and [existing] and add
      //
      // * a [1, 2) is required
      var intersection = _intersectDeps([existing.dep, fact.dep]);
      if (intersection == null) {
        throw "Incompatible constraints!";
      }
  