Don't try to look up the root package in the default source.

utils/pub/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.
 
 /**
  * Attempts to resolve a set of version constraints for a package dependency
  * graph and select an appropriate set of best specific versions for all
  * dependent packages. It works iteratively and tries to reach a stable
  * solution where the constraints of all dependencies are met. If it fails to
  * reach a solution after a certain number of iterations, it assumes the
@@ skipping 36 matching lines @@
 /**
  * Attempts to select the best concrete versions for all of the transitive
  * dependencies of [root] taking into account all of the [VersionConstraint]s
  * that those dependencies place on each other. If successful, completes to a
  * [Map] that maps package names to the selected version for that package. If
  * it fails, the future will complete with a [NoVersionException],
  * [DisjointConstraintException], or [CouldNotSolveException].
  */
 Future<Map<String, Version>> resolveVersions(
     SourceRegistry sources, Package root) {
-  return new VersionSolver(sources).solve(root);
+  return new VersionSolver(sources, root).solve();
 }
 
 class VersionSolver {
   final SourceRegistry _sources;
+  final Package _root;
   final PubspecCache _pubspecs;
   final Map<String, Dependency> _packages;
   final Queue<WorkItem> _work;
   int _numIterations = 0;
 
-  VersionSolver(SourceRegistry sources)
+  VersionSolver(SourceRegistry sources, Package root)
       : _sources = sources,
+        _root = root,
         _pubspecs = new PubspecCache(sources),
         _packages = <Dependency>{},
         _work = new Queue<WorkItem>();
 
-  Future<Map<String, Version>> solve(Package root) {
+  Future<Map<String, Version>> solve() {
     // Kick off the work by adding the root package at its concrete version to
     // the dependency graph.
-    _pubspecs.cache(root);
-    enqueue(new ChangeConstraint('(entrypoint)', root.name, root.version));
+    _pubspecs.cache(_root);
+    enqueue(new ChangeConstraint('(entrypoint)', _root.name, _root.version));
 
     Future processNextWorkItem(_) {
       while (true) {
         // Stop if we are done.
         if (_work.isEmpty()) return new Future.immediate(buildResults());
 
         // If we appear to be stuck in a loop, then we probably have an unstable
         // graph, bail. We guess this based on a rough heuristic that it should
         // only take a certain number of steps to solve a graph with a given
         // number of connections.
@@ skipping 174 matching lines @@
     // If this constraint change didn't cause the overall constraint on the
     // package to change, then we don't need to do any further work.
     if (oldConstraint == newConstraint) return null;
 
     // If the dependency has been cut free from the graph, just remove it.
     if (!dependency.isDependedOn) {
       solver.enqueue(new ChangeVersion(dependent, null));
       return null;
     }
 
+    // If the dependency is on the root package, then we don't need to do
+    // anything since it's already at the best version.
+    if (dependent == solver._root.name) {
+      solver.enqueue(new ChangeVersion(dependent, solver._root.version));
+      return null;
+    }
+
     // The constraint has changed, so see what the best version of the package
     // that meets the new constraint is.
     // TODO(rnystrom): Should this always be the default source?
     var source = solver._sources.defaultSource;
     return source.getVersions(dependent).transform((versions) {
       var best = null;
       for (var version in versions) {
         if (newConstraint.allows(version)) {
           if (best == null || version > best) best = version;
         }
@@ skipping 134 matching lines @@
 /**
  * Exception thrown when the [VersionSolver] fails to find a solution after a
  * certain number of iterations.
  */
 class CouldNotSolveException implements Exception {
   CouldNotSolveException();
 
   String toString() =>
       "Could not find a solution that met all version constraints.";
 }