anchor.diff:      // * a [1, 2) is required
       _required.remove(fact.dep.name);
       var trimmed = _requiredAndDisallowed(required, disallowed);
  -
  -    // Add to [_toProcess] because [_fromCurrent] will get discarded when we
  -    // return `false`.
  -    if (trimmed != null) _toProcess.add(trimmed);
  +    if (trimmed != null) _replaceCurrent(trimmed);
       return false;
     }
   
  
positive.code:       //
        // we can throw away [dependency].
        return null;
      } else if (intersection.constraint == dependency.allowed.constraint) {
        // If [intersection] is exactly [dependency.allowed.constraint], then
        // [dependency] can be preserved as-is. For example, if
        //
  
negative.code: 
      /// Trim [fact]'s allowed version if it's not covered by a requirement.
      required = _required[fact.allowed.name];
      if (required == null) return true;
  
      var result = _requiredAndAllowed(required, fact);
      if (result == fact) return true;
      if (result != null) _replaceCurrent(result);
      return false;
    }
  
    bool _dependencyIntoDisallowed(Dependency fact) {
      // Trim [fact] if some of its depender is disallowed.
      var disallowed = _disallowed[fact.depender.toRef()];
      if (disallowed != null) {
        var result = _disallowedAndDepender(disallowed, fact);
        if (result != fact) {
          if (result != null) _replaceCurrent(result);
          return false;
        }
      }
  
      // Trim [fact] if some of its allowed versions are disallowed.
      disallowed = _disallowed[fact.allowed.toRef()];
      if (disallowed != null) {
        var result = _disallowedAndAllowed(disallowed, fact);
        if (result != fact) {
          if (result != null) _replaceCurrent(result);
          return false;
        }
      }
  
      return true;
    }
  
    void _dependencyIntoIncompatibilities(Dependency fact) {
  