anchor.diff:      return merge(fact.dep2);
     }
   
  +  bool _incompatibilityIntoRequired(Incompatibility fact) {
  +    var required = _required[fact.dep1.name] ?? _required[fact.dep2.name];
  +    if (required == null) return true;
  +    var result = _requiredAndIncompatibility(fact);
  +
  +    // Add to [_toProcess] because [_fromCurrent] will get discarded when we
  +    // return `false`.
  +    if (result != null) _toProcess.add(result);
  +    return false;
  +  }
  +
     // Resolves [required] and [disallowed], which should refer to the same
     // package.
     //
  
positive.code:   void _requiredIntoIncompatibilities(Required fact) {
      // Remove any incompatibilities that are no longer relevant.
      for (var incompatibility in _incompatibilities[fact.dep.toRef()].toList()) {
        var same = _matching(incompatibility, fact.dep);
        var different = _nonMatching(incompatibility, fact.dep);
  
        // The versions of [fact.dep] that aren't in [same], and thus that are
        // compatible with [different].
        var compatible = fact.dep.constraint.difference(same.constraint);
        _removeIncompatibility(incompatibility);
  
        if (compatible.isEmpty) {
          // If [fact] is incompatible with all versions of [different], then
          // [different] must be disallowed entirely. For example, if
          //
          // * a [0, 1) is required (fact)
          // * a [0, 1) is incompatible with b [0, 1) (incompatibility)
          //
          // we can remove [incompatibility] and add
          //
          // * b [0, 1) is disallowed
          _fromCurrent.add(new Disallowed(different, [incompatibility, fact]));
        } else if (compatible != fact.dep.constraint) {
          // If [fact] allows versions outside of [same], then we can reframe this
          // incompatibility as a dependency from [different] onto [fact.dep].
          // This is safe because [fact.dep] needs to be selected anyway. For
          // example, if
          //
          // * a [0, 2) is required (fact)
          // * a [0, 1) is incompatible with b [0, 1) (incompatibility)
          //
          // we can remove [incompatibility] and add
          //
          // * b [0, 1) depends on a [1, 2)
          _fromCurrent.add(new Dependency(
              different,
              same.withConstraint(compatible),
              [incompatibility, fact]));
        } else {
          // There's no need to do anything else if *all* the versions allowed by
          // [fact] are outside of [same], since one of those versions is already
          // required. For example, if
          //
          // * a [0, 1) is required (fact)
          // * a [1, 2) is incompatible with b [0, 1) (incompatibility)
          //
          // we can throw away [incompatibility].
        }
      }
    }
  
  
negative.code:       } else if (fact is Incompatibility) {
          fact = _incompatibilityIntoIncompatibilities(fact);
          if (fact == null) continue;
  
          if (!_incompatibilityIntoRequired(fact)) continue;
  
          _incompatibilities
              .putIfAbsent(fact.dep1.toRef(), () => new Set())
              .add(fact);
          _incompatibilities
              .putIfAbsent(fact.dep2.toRef(), () => new Set())
              .add(fact);
        }
  
        _toProcess.addAll(_fromCurrent);
  