Upgrade the version solver's algorithm

lib/src/package_name.dart

@@ -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/solver/assignment.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 the assignment isn't a derivation.
+  final Incompatibility cause;
+
+  Assignment(
+      PackageName package, bool isPositive, this.decisionLevel, this.index,
+      {this.cause})
+      : super(package, isPositive);
+}

lib/src/solver/incompatibility.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 normalizes [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";
+    }
+  }
+}