anchor.diff:            ? incompatibility.dep2
             : incompatibility.dep1;
   
  -  // Merge two deps, [_allIds] aware to reduce gaps. Algorithm TBD.
  -  PackageDep _mergeDeps(PackageDep dep1, PackageDep dep2);
  +  // Merge [deps], [_allIds]-aware to reduce gaps. `null` if the deps are
  +  // incompatible source/desc. Algorithm TBD.
  +  PackageDep _mergeDeps(Iterable<PackageDep> deps);
   
     // Intersect two deps, return `null` if they aren't compatible (diff name, diff
     // source, diff desc, or non-overlapping).
  
positive.code:       if (intersection.isEmpty) {
          // If no versions in [fact] have this dependencies, then it's irrelevant.
          _removeDependency(dependency);
        } else if (intersection == fact.dep.constraint) {
          // If all versions in [fact] have this dependency, then it can be
          // upgraded to a requirement.
          _removeDependency(dependency);
          _toProcess.add(new Required(dependency.allowed, [dependency, fact]));
        } else if (intersection != dependency.depender.constraint) {
          // If only some versions [dependency.depender] are in [fact], we can
          // trim the ones that aren't.
          _toProcess.add(new Dependency(
              dependency.depender.withConstraint(intersection),
              dependency.allowed,
              [dependency, fact]));
        }
      }
  
      for (var dependency in _dependenciesByAllowed[ref].toList()) {
        var intersection = dependency.allowed.constraint.intersect(
  
negative.code:   }
  
    void _requiredIntoDependencies(Required fact) {
      // Dependencies whose depender is [fact.dep], grouped by the names of
      // packages they depend on.
      var matchingByAllowed = <String, Set<Dependency>>{};
  
      var ref = fact.dep.toRef();
      for (var dependency in _dependenciesByDepender[ref].toList()) {
        var intersection = fact.dep.constraint
  