Improve the readability of Incompatibility.toString()

Non-derived incompatibilities now indicate their causes, and terms
with any constraints no longer list their constraints explicitly.

Author: nex3

lib/src/solver/incompatibility.dart

@@ -68,25 +68,70 @@ class Incompatibility {
   Incompatibility._(this.terms, this.cause);
 
   String toString() {
+    if (cause == IncompatibilityCause.dependency) {
+      assert(terms.length == 2);
+
+      var depender = terms.first;
+      var dependee = terms.last;
+      assert(depender.isPositive);
+      assert(!dependee.isPositive);
+
+      if (depender.constraint.isAny) {
+        return "all versions of ${_terseRef(depender)} "
+            "depend on ${dependee.package.toTerseString()}";
+      } else {
+        return "${depender.package.toTerseString()} depends on "
+            "${dependee.package.toTerseString()}";
+      }
+    } else if (cause == IncompatibilityCause.sdk) {
+      assert(terms.length == 1);
+      assert(terms.first.isPositive);
+
+      // TODO(nweiz): Include more details about the expected and actual SDK
+      // versions.
+      if (terms.first.constraint.isAny) {
+        return "no versions of ${_terseRef(terms.first)} "
+            "are compatible with the current SDK";
+      } else {
+        return "${terms.first.package.toTerseString()} is incompatible with "
+            "the current SDK";
+      }
+    } else if (cause == IncompatibilityCause.noVersions) {
+      assert(terms.length == 1);
+      assert(terms.first.isPositive);
+      return "no versions of ${_terseRef(terms.first)} "
+          "match ${terms.first.constraint}";
+    } else if (isFailure) {
+      return "version solving failed";
+    }
+
     if (terms.length == 1) {
       var term = terms.single;
-      return "${term.package.toTerseString()} is "
-          "${term.isPositive ? 'forbidden' : 'required'}";
+      if (term.constraint.isAny) {
+        return "${_terseRef(term)} is "
+            "${term.isPositive ? 'forbidden' : 'required'}";
+      } else {
+        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()}";
+      if (term1.isPositive == term2.isPositive) {
+        if (term1.isPositive) {
+          var package1 = term1.constraint.isAny
+              ? _terseRef(term1)
+              : term1.package.toTerseString();
+          var package2 = term2.constraint.isAny
+              ? _terseRef(term2)
+              : term2.package.toTerseString();
+          return "$package1 is incompatible with $package2";
+        } else {
+          return "either ${term1.package.toTerseString()} or "
+              "${term2.package.toTerseString()}";
+        }
       }
     }
 
@@ -97,11 +142,24 @@ class Incompatibility {
     }
 
     if (positive.isNotEmpty && negative.isNotEmpty) {
-      return "if ${positive.join(' and ')} then ${negative.join(' and ')}";
+      if (positive.length == 1) {
+        var positiveTerm = terms.firstWhere((term) => term.isPositive);
+        if (positiveTerm.constraint.isAny) {
+          return "all versions of ${_terseRef(positiveTerm)} require "
+              "${negative.join(' or ')}";
+        } else {
+          return "${positive.first} requires ${negative.join(' or ')}";
+        }
+      } else {
+        return "if ${positive.join(' and ')} then ${negative.join(' or ')}";
+      }
     } else if (positive.isNotEmpty) {
       return "one of ${positive.join(' or ')} must be false";
     } else {
       return "one of ${negative.join(' or ')} must be true";
     }
   }
+
+  /// Returns a terse representation of term's package ref.
+  String _terseRef(Term term) => term.package.toRef().toTerseString();
 }