Upgrade the version solver's algorithm

This introduces a new algorithm I call "Pubgrub" which is based on
cutting-edge techniques for NP-hard search problems. It should
substantially reduce the number of cases where the version solver goes
exponential, and make it much easier to provide thorough error
messages when no solution is available.

This commit adds the core of the algorithm, but it's not yet feature-
complete with the old version solver. I intend to add support for
features like locked dependencies, downgrading, and so on in follow-up
CLs. It also doesn't have any kind of error handling yet. As such,
pub's test suite is not expected to pass.

See #912

Author: nex3

doc/solver.md

@@ -48,12 +48,6 @@ abstract class PackageName {
         description = null,
         isMagic = true;
 
-  String toString() {
-    if (isRoot) return "$name (root)";
-    if (isMagic) return name;
-    return "$name from $source";
-  }
-
   /// Returns a [PackageRef] with this one's [name], [source], and
   /// [description].
   PackageRef toRef() => isMagic
@@ -82,6 +76,9 @@ abstract class PackageName {
         source.hashCode ^
         source.hashDescription(description);
   }
+
+  /// Like [toString], but leaves off some information for extra terseness.
+  String toTerseString();
 }
 
 /// A reference to a [Package], but not any particular version(s) of it.
@@ -98,6 +95,18 @@ class PackageRef extends PackageName {
   /// Creates a reference to a magic package (see [isMagic]).
   PackageRef.magic(String name) : super._magic(name);
 
+  String toString() {
+    if (isRoot) return "$name (root)";
+    if (isMagic) return name;
+    return "$name from $source";
+  }
+
+  String toTerseString() {
+    if (isMagic) return name;
+    if (isRoot || source.name != 'hosted') return "$name";
+    return "$name from $source";
+  }
+
   bool operator ==(other) => other is PackageRef && samePackage(other);
 }
 
@@ -146,6 +155,12 @@ class PackageId extends PackageName {
     if (isMagic) return name;
     return "$name $version from $source";
   }
+
+  String toTerseString() {
+    if (isMagic) return name;
+    if (isRoot || source.name == 'hosted') return "$name $version";
+    return "$name $version from $source";
+  }
 }
 
 /// A reference to a constrained range of versions of one package.
@@ -214,6 +229,12 @@ class PackageRange extends PackageName {
     return "$prefix ($description)";
   }
 
+  String toTerseString() {
+    if (isMagic) return name;
+    if (isRoot || source.name == 'hosted') return "$name $constraint";
+    return "$name $constraint from $source";
+  }
+
   /// Returns a new [PackageRange] with [features] merged with [this.features].
   PackageRange withFeatures(Map<String, FeatureDependency> features) {
     if (features.isEmpty) return this;

lib/src/package_name.dart

@@ -0,0 +1,26 @@
+// Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import '../package_name.dart';
+import 'incompatibility.dart';
+import 'term.dart';
+
+/// A term in a [PartialSolution] that tracks some additional metadata.
+class Assignment extends Term {
+  /// The number of decisions at or before this in the [PartialSolution] that
+  /// contains it.
+  final int decisionLevel;
+
+  /// The index of this assignment in [PartialSolution.assignments].
+  final int index;
+
+  /// The incompatibility that caused this assignment to be derived, or `null`
+  /// if it isn't a derivation.
+  final Incompatibility cause;
+
+  Assignment(
+      PackageName package, bool isPositive, this.decisionLevel, this.index,
+      {this.cause})
+      : super(package, isPositive);
+}

lib/src/solver/assignment.dart

@@ -0,0 +1,97 @@
+// Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import '../package_name.dart';
+import 'term.dart';
+
+/// A set of mutually-incompatible terms.
+///
+/// See https://github.com/dart-lang/pub/tree/master/doc/solver.md#incompatibility.
+class Incompatibility {
+  /// The mutually-incompatibile terms.
+  final List<Term> terms;
+
+  /// Creates an incompatibility with [terms].
+  ///
+  /// This normalized [terms] so that each package has at most one term
+  /// referring to it.
+  factory Incompatibility(List<Term> terms) {
+    if (terms.length == 1 ||
+        // Short-circuit in the common case of a two-term incompatibility with
+        // two different packages (for example, a dependency).
+        (terms.length == 2 &&
+            terms.first.package.name != terms.last.package.name)) {
+      return new Incompatibility._(terms);
+    }
+
+    // Coalesce multiple terms about the same package if possible.
+    var byName = <String, Map<PackageRef, Term>>{};
+    for (var term in terms) {
+      var byRef = byName.putIfAbsent(term.package.name, () => {});
+      var ref = term.package.toRef();
+      if (byRef.containsKey(ref)) {
+        byRef[ref] = byRef[ref].intersect(term);
+
+        // If we have two terms that refer to the same package but have a null
+        // intersection, they're mutually exclusive, making this incompatibility
+        // irrelevant, since we already know that mutually exclusive version
+        // ranges are incompatible. We should never derive an irrelevant
+        // incompatibility.
+        assert(byRef[ref] != null);
+      } else {
+        byRef[ref] = term;
+      }
+    }
+
+    return new Incompatibility._(byName.values.expand((byRef) {
+      // If there are any positive terms for a given package, we can discard
+      // any negative terms.
+      var positiveTerms =
+          byRef.values.where((term) => term.isPositive).toList();
+      if (positiveTerms.isNotEmpty) return positiveTerms;
+
+      return byRef.values;
+    }).toList());
+  }
+
+  Incompatibility._(this.terms);
+
+  String toString() {
+    if (terms.length == 1) {
+      var term = terms.single;
+      return "${term.package.toTerseString()} is "
+          "${term.isPositive ? 'forbidden' : 'required'}";
+    }
+
+    if (terms.length == 2) {
+      var term1 = terms.first;
+      var term2 = terms.last;
+      if (term1.isPositive != term2.isPositive) {
+        var positive = (term1.isPositive ? term1 : term2).package;
+        var negative = (term1.isPositive ? term2 : term1).package;
+        return "if ${positive.toTerseString()} then ${negative.toTerseString()}";
+      } else if (term1.isPositive) {
+        return "${term1.package.toTerseString()} is incompatible with "
+            "${term2.package.toTerseString()}";
+      } else {
+        return "either ${term1.package.toTerseString()} or "
+            "${term2.package.toTerseString()}";
+      }
+    }
+
+    var positive = <String>[];
+    var negative = <String>[];
+    for (var term in terms) {
+      (term.isPositive ? positive : negative).add(term.package.toTerseString());
+    }
+
+    if (positive.isNotEmpty && negative.isNotEmpty) {
+      return "if ${positive.join(' and ')} then ${negative.join(' and ')}";
+    } else if (positive.isNotEmpty) {
+      return "one of ${positive.join(' or ')} must be false";
+    } else {
+      return "one of ${negative.join(' or ')} must be true";
+    }
+  }
+}