anchor.diff:            if (dependencyDifference != null) {
               // If [intersection] covers the entirety of [dependency], throw it
               // away; otherwise, trim it to exclude [intersection].
  -            _toProcess.add(new Dependency(
  +            _fromCurrent.add(new Dependency(
                   dependencyDifference, dependency.allowed, [dependency, fact]));
             }
   
  
positive.code:           _removeDependency(dependency);
  
            // If [dependency] allows strictly more versions than [fact], remove
            // any overlap from [dependency] because it's less specific.
            var difference = _depMinus(dependency.depender, fact.depender);
            if (difference == null) continue;
  
            _toProcess.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.
            _removeDependency(dependency);
  
            var intersection = _intersectDeps(dependency.depender, fact.depender);
            _toProcess.add(new Dependency(
                intersection,
                _intersectDeps(dependency.allowed, fact.allowed),
                [dependency, fact]));
  
negative.code: 
        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].
        }
      }
    }
  
    Disallowed _disallowedIntoDisallowed(Disallowed fact) {
      var ref = fact.dep.asRef();
      var existing = _disallowed[ref];
      if (existing == null) return true;
  
      /// Merge two disalloweds on the same package. For example, if:
      ///
      /// * a [0, 1) is disallowed (fact)
      /// * a [1, 2) is disallowed (existing)
      ///
      /// we can remove both [fact] and [existing] and add
      ///
      /// * a [0, 2) is disallowed
      _disallowed.remove(ref);
      return new Disallowed(
          _mergeDeps([fact.dep, existing.dep]), [existing, fact]);
    }
  
    bool _disallowedIntoRequired(Disallowed fact) {
  