anchor.diff:        //
         // * b [0, 1) is disallowed
         return new Disallowed(dependency.depender, [dependency, required]);
  -    } else if (intersection.constraint == required.dep.constraint) {
  +    } else if (intersection == required.dep) {
         // If [intersection] is exactly [required.dep], then this dependency adds
         // no information in addition to [required], so it can be discarded
         // entirely. For example, if
  
positive.code:     for (var dependency in _dependenciesByDepender(fact.depender.toRef())) {
        if (dependency.allowed.toRef() != fact.allowed.toRef()) continue;
  
        if (dependency.allowed.constraint == fact.allowed.constraint) {
          // If [fact] has the same allowed constraint as [dependency], they can
          // be merged. For example, if
          //
          // * a [0, 1) depends on b [0, 1) (fact)
          // * a [1, 2) depends on b [0, 1) (dependency)
          //
          // we can remove both [fact] and [dependency] and add
          //
          // * a [0, 2) depends on b [0, 1).
          var merged = _mergeDeps([dependency.depender, fact.depender]);
  
          // If [fact] adds no new information to [dependency], it's redundant.
          if (merged.constraint == dependency.depender.constraint) return null;
  
          // If [fact] adds new information to [dependency], create a new
          // dependency for it.
          _removeDependency(dependency);
          fact = new Dependency(merged, fact.allowed, [dependency, fact]);
        } else if (
            dependency.depender.constraint.allowsAny(fact.depender.constraint)) {
          // If [fact] has a different allowed constraint than [dependency] but
          // their dependers overlap, remove the part that's overlapping. This
          // ensures that, for a given depender/allowed pair, there will be only
          // one dependency for each depender version.
  
          if (fact.allowed.constraint.allowsAll(dependency.allowed.constraint)) {
            // If [fact] allows strictly more versions than [dependency], remove
            // any overlap from [fact] because it's less specific. For example,
            // if
            //
            // * a [1, 3) depends on b [0, 2) (fact)
            // * a [2, 4) depends on b [1, 2) (dependency)
            //
            // we can remove [fact] and add
            //
            // * a [1, 2) depends on b [0, 2).
            var difference = _depMinus(fact.depender, dependency.depender);
            if (difference == null) return null;
  
            fact = new Dependency(difference, fact.allowed, [dependency, fact]);
          } else if (dependency.allowed.constraint
              .allowsAll(fact.allowed.constraint)) {
            _removeDependency(dependency);
  
            // If [dependency] allows strictly more versions than [fact], remove
            // any overlap from [dependency] because it's less specific. For
            // example, if
            //
            // * a [1, 3) depends on b [1, 2) (fact)
            // * a [2, 4) depends on b [0, 2) (dependency)
            //
            // we can remove [dependency] and add
            //
            // * a [3, 4) depends on b [0, 2).
            var difference = _depMinus(dependency.depender, fact.depender);
            if (difference == null) continue;
  
            _fromCurrent.add(new Dependency(
                difference, dependency.allowed, [dependency, fact]));
          } else {
            // If [fact] and [dependency]'s allowed targets overlap without one
            // being a subset of the other, we need to create a third dependency
            // that represents the intersection. For example, if
            //
            // * a [1, 3) depends on b [0, 2) (fact)
            // * a [2, 4) depends on b [1, 3) (dependency)
            //
            // we can remove both [fact] and [dependency] and add
            //
            // * a [1, 2) depends on b [0, 2)
            // * a [2, 3) depends on b [1, 2)
            // * a [3, 4) depends on b [1, 3)
            _removeDependency(dependency);
  
            var intersection = _intersectDeps([dependency.depender, fact.depender]);
            _fromCurrent.add(new Dependency(
                intersection,
                _intersectDeps([dependency.allowed, fact.allowed]),
                [dependency, fact]));
  
            var dependencyDifference = _depMinus(dependency, intersection);
            if (dependencyDifference != null) {
              // If [intersection] covers the entirety of [dependency], throw it
              // away; otherwise, trim it to exclude [intersection].
              _fromCurrent.add(new Dependency(
                  dependencyDifference, dependency.allowed, [dependency, fact]));
            }
  
            var factDifference = _depMinus(fact, intersection);
            if (factDifference == null) return null;
  
            // If [intersection] covers the entirety of [fact], throw it away;
            // otherwise, trim it to exclude [intersection].
            fact = new Dependency(
                factDifference, fact.allowed, [dependency, fact]);
          }
        } else {
          siblings.add(dependency);
        }
      }
  
  
negative.code:           dependency.depender, allowed, [dependency].addAll(relevant)));
      }
  
      return true;
    }
  
    bool _dependencyIntoRequired(Dependency fact) {
      var required = _required[fact.depender.name];
      if (required != null) {
        if (required.toRef() != fact.depender.toRef()) return false;
  
        // Trim [fact] or throw it away if it's irrelevant. For example, if
        //
  