anchor.diff:        if (intersection.isEmpty) {
           // If there are no valid versions covered by both [dependency.allowed]
           // and [fact], then this dependency can never be satisfied and the
  -        // depender should be disallowed entirely.
  -        _toProcess.add(new Disallowed(dependency.depender, [dependency, fact]));
  +        // depender should be disallowed entirely. For example, if
  +        //
  +        // * a [0, 1) is required (fact)
  +        // * b [0, 1) depends on a [1, 2) (dependency)
  +        //
  +        // we can remove [dependency] and add
  +        //
  +        // * b [0, 1) is disallowed
  +        _fromCurrent.add(new Disallowed(dependency.depender, [dependency, fact]));
         } else if (intersection != fact.dep.constraint) {
           // If some but not all packages covered by [dependency.allowed] are
           // covered by [fact], replace [dependency] with one with a narrower
  -        // constraint.
  -        //
  -        // If [intersection] is exactly [fact.dep.constraint], then this
  -        // dependency adds no information in addition to [fact], so it can be
  -        // discarded entirely.
  -        _toProcess.add(new Dependency(
  +        // constraint. For example, if
  +        //
  +        // * a [0, 2) is required (fact)
  +        // * b [0, 1) depends on a [1, 3) (dependency)
  +        //
  +        // we can remove [dependency] and add
  +        //
  +        // * b [0, 1) depends on a [1, 2)
  +        _fromCurrent.add(new Dependency(
               dependency.depender,
               dependency.allowed.withConstraint(intersection),
               [dependency, fact]));
  +      } else {
  +        // If [intersection] is exactly [fact.dep.constraint], then this
  +        // dependency adds no information in addition to [fact], so it can be
  +        // discarded entirely. For example, if
  +        //
  +        // * a [0, 1) is required (fact)
  +        // * b [0, 1) depends on a [0, 1) (dependency)
  +        //
  +        // we can throw away [dependency].
         }
       }
     }
  
positive.code: 
        if (intersection.isEmpty) {
          // If no versions in [fact] have this dependency, then it's irrelevant.
          _removeDependency(dependency);
        } else if (intersection != dependency.depender.constraint) {
          // If only some versions [dependency.depender] are in [fact], we can
          // trim the ones that aren't.
          _removeDependency(dependency);
          var newDependency = new Dependency(
              dependency.depender.withConstraint(intersection),
              dependency.allowed,
              [dependency, fact]);
          _toProcess.add(newDependency);
          matchingByAllowed[newDependency.allowed.name] = newDependency;
        } else {
          matchingByAllowed[dependency.allowed.name] = dependency;
  
negative.code:     if (required == null) return true;
  
      // If there's a [Required] matching [fact], delete [fact] and modify the
      // [Required] instead. We prefer [Required] because it's more specific. For
      // example, if
      //
      // * a [0, 1) is disallowed (fact)
      // * a [0, 2) is required (required)
      //
      // we can remove [fact] and [required] and add
      //
      // * 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);
      return false;
    }
  
  