Rewrite pub's version solver.

sdk/lib/_internal/pub/lib/src/solver/version_solver.dart

 // Copyright (c) 2012, 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.
 
 library pub.solver.version_solver;
 
 import 'dart:async';
 import "dart:convert";
 
 import 'package:pub_semver/pub_semver.dart';
@@ skipping 196 matching lines @@
   ///
   /// Packages are sorted in descending version order with all "stable"
   /// versions (i.e. ones without a prerelease suffix) before pre-release
   /// versions. This ensures that the solver prefers stable packages over
   /// unstable ones.
   Future<List<PackageId>> getVersions(PackageRef package) async {
     if (package.isRoot) {
       throw new StateError("Cannot get versions for root package $package.");
     }
 
+    if (package.isMagic) return [new PackageId.magic(package.name)];
+
     // See if we have it cached.
     var versions = _versions[package];
     if (versions != null) {
       _versionCacheHits++;
       return versions;
     }
 
     // See if we cached a failure.
     var error = _versionErrors[package];
     if (error != null) {
       _versionCacheHits++;
       await new Future.error(error.first, error.last);
     }
 
     _versionCacheMisses++;
 
     var source = _sources[package.source];
     var pubspecs;
     try {
       pubspecs = await source.getVersions(package.name, package.description);
     } catch (error, stackTrace) {
       // If an error occurs, cache that too. We only want to do one request
       // for any given package, successful or not.
-      log.solver("Could not get versions for $package:\n$error\n\n$stackTrace");
-      _versionErrors[package] = new Pair(error, new Chain.forTrace(stackTrace));
+      var chain = new Chain.forTrace(stackTrace);
+      log.solver("Could not get versions for $package:\n$error\n\n" +
+          chain.terse.toString());
+      _versionErrors[package] = new Pair(error, chain);
       throw error;
     }
 
     // Sort by priority so we try preferred versions first.
     pubspecs.sort((pubspec1, pubspec2) {
       return _type == SolveType.DOWNGRADE
           ? Version.antiprioritize(pubspec1.version, pubspec2.version)
           : Version.prioritize(pubspec1.version, pubspec2.version);
     });
 
@@ skipping 21 matching lines @@
 
     // Uncomment this to dump the visited package graph to JSON.
     //results += _debugWritePackageGraph();
 
     return results;
   }
 }
 
 /// A reference from a depending package to a package that it depends on.
 class Dependency {
-  /// The name of the package that has this dependency.
-  final String depender;
-
-  /// The version of the depender that has this dependency.
-  final Version dependerVersion;
+  /// The package that has this dependency.
+  final PackageId depender;
 
   /// The package being depended on.
   final PackageDep dep;
 
-  /// Whether [depender] is a magic dependency (e.g. "pub itself" or "pub global
-  /// activate").
-  bool get isMagic => depender.contains(" ");
+  Dependency(this.depender, this.dep);
 
-
-  Dependency(this.depender, this.dependerVersion, this.dep);
-
-  String toString() => '$depender $dependerVersion -> $dep';
+  String toString() => '$depender -> $dep';
 }
 
 /// An enum for types of version resolution.
 class SolveType {
   /// As few changes to the lockfile as possible to be consistent with the
   /// pubspec.
   static const GET = const SolveType._("get");
 
   /// Upgrade all packages or specific packages to the highest versions
   /// possible, regardless of the lockfile.
@@ skipping 32 matching lines @@
   SolveFailure(this.package, Iterable<Dependency> dependencies)
       : dependencies = dependencies != null ? dependencies : <Dependency>[];
 
   String toString() {
     if (dependencies.isEmpty) return _message;
 
     var buffer = new StringBuffer();
     buffer.write("$_message:");
 
     var sorted = dependencies.toList();
-    sorted.sort((a, b) => a.depender.compareTo(b.depender));
+    sorted.sort((a, b) => a.depender.name.compareTo(b.depender.name));
 
     for (var dep in sorted) {
       buffer.writeln();
-      buffer.write("- ${log.bold(dep.depender)}");
-      if (!dep.isMagic) buffer.write(" ${dep.dependerVersion}");
+      buffer.write("- ${log.bold(dep.depender.name)}");
+      if (!dep.depender.isMagic && !dep.depender.isRoot) {
+        buffer.write(" ${dep.depender.version}");
+      }
       buffer.write(" ${_describeDependency(dep.dep)}");
     }
 
     return buffer.toString();
   }
 
   /// Describes a dependency's reference in the output message.
   ///
   /// Override this to highlight which aspect of [dep] led to the failure.
   String _describeDependency(PackageDep dep) =>
@@ skipping 75 matching lines @@
       "depends on it from source ${dep.source}";
 }
 
 /// Exception thrown when a dependency on an unknown source name is found.
 class UnknownSourceException extends SolveFailure {
   UnknownSourceException(String package, Iterable<Dependency> dependencies)
       : super(package, dependencies);
 
   String toString() {
     var dep = dependencies.single;
-    return 'Package ${dep.depender} depends on ${dep.dep.name} from unknown '
-           'source "${dep.dep.source}".';
+    return 'Package ${dep.depender.name} depends on ${dep.dep.name} from '
+           'unknown source "${dep.dep.source}".';
   }
 }
 
 /// Exception thrown when two packages with the same name and source but
 /// different descriptions are depended upon.
 class DescriptionMismatchException extends SolveFailure {
   String get _message => "Incompatible dependencies on $package";
 
   DescriptionMismatchException(String package,
       Iterable<Dependency> dependencies)
@@ skipping 15 matching lines @@
 
   DependencyNotFoundException(String package, this._innerException,
       Iterable<Dependency> dependencies)
       : super(package, dependencies);
 
   /// The failure isn't because of the version of description of the package,
   /// it's the package itself that can't be found, so just show the name and no
   /// descriptive details.
   String _describeDependency(PackageDep dep) => "";
 }