Don't extract the name of a package from its description.

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 75 matching lines @@
   void useLatestVersion(String package) {
     // TODO(nweiz): How do we want to detect and handle unknown dependencies
     // here?
     getDependency(package).useLatestVersion = true;
     lockFile.packages.remove(package);
   }
 
   Future<List<PackageId>> solve() {
     // Kick off the work by adding the root package at its concrete version to
     // the dependency graph.
-    var ref = new PackageRef(new RootSource(_root), _root.version, _root.name);
+    var ref = new PackageRef(
+        _root.name, new RootSource(_root), _root.version, _root.name);
     enqueue(new AddConstraint('(entrypoint)', ref));
     _pubspecs.cache(ref.atVersion(_root.version), _root.pubspec);
 
     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
@@ skipping 36 matching lines @@
    */
   void setVersion(String package, Version version) {
     _packages[package].version = version;
   }
 
   /**
    * Returns the most recent version of [dependency] that satisfies all of its
    * version constraints.
    */
   Future<Version> getBestVersion(Dependency dependency) {
-    return dependency.source.getVersions(dependency.description)
-        .transform((versions) {
+    return dependency.getVersions().transform((versions) {
       var best = null;
       for (var version in versions) {
         if (dependency.useLatestVersion ||
             dependency.constraint.allows(version)) {
           if (best == null || version > best) best = version;
         }
       }
 
       // TODO(rnystrom): Better exception.
       if (best == null) {
@@ skipping 37 matching lines @@
       // If the lockfile contains a fully-resolved description for the package,
       // use that. This allows e.g. Git to ensure that the same commit is used.
       var lockedPackage = lockFile.packages[dep.name];
       if (lockedPackage != null && lockedPackage.version == dep.version &&
           lockedPackage.source.name == dep.source.name &&
           dep.source.descriptionsEqual(
               description, lockedPackage.description)) {
         description = lockedPackage.description;
       }
 
-      return new PackageId(dep.source, dep.version, description);
+      return new PackageId(dep.name, dep.source, dep.version, description);
     });
   }
 }
 
 /**
  * The constraint solver works by iteratively processing a queue of work items.
  * Each item is a single atomic change to the dependency graph. Handling them
  * in a queue lets us handle asynchrony (resolving versions requires information
  * from servers) as well as avoid deeply nested recursion.
 */
 abstract class WorkItem {
   /**
    * Processes this work item. Returns a future that completes when the work is
    * done. If `null` is returned, that means the work has completed
    * synchronously and the next item can be started immediately.
    */
   Future process(VersionSolver solver);
 }
 
 /**
  * The best selected version for a package has changed to [version]. If the
  * previous version of the package is `null`, that means the package is being
  * added to the graph. If [version] is `null`, it is being removed.
  */
 class ChangeVersion implements WorkItem {
+  /// The name of the package whose version is being changed.
+  final String package;

[Bob Nystrom, 2012/09/18 01:34:47]

This now has a name, source, description, and version. Can you just use a
PackageRef (with the understanding that the version constraint will always be a
concrete version)?

[nweiz, 2012/09/18 19:55:30]

I still feel like the semantics of the version identification here are slightly
different from the semantics of PackageId. PackageId represents a version of a
package, whereas this represents the change in that version. One concrete way
this manifests is the nullability of version; ChangeVersion.version is intended
to be nullable, since it can represent removing a dependency, whereas
PackgeId.version cannot be null because there can't be a package with no
version.

+
   /**
    * The source of the package whose version is changing.
    */
   final Source source;
 
   /**
    * The description identifying the package whose version is changing.
    */
   final description;
 
   /**
    * The new selected version.
    */
   final Version version;
 
-  /**
-   * The name of the package whose version is changing.
-   */
-  String get package => source.packageName(description);
-
-  ChangeVersion(this.source, this.description, this.version) {
+  ChangeVersion(this.package, this.source, this.description, this.version) {
     if (source == null) throw "null source";
   }
 
   Future process(VersionSolver solver) {
     var dependency = solver.getDependency(package);
     var oldVersion = dependency.version;
     solver.setVersion(package, version);
 
     // The dependencies between the old and new version may be different. Walk
     // them both and update any constraints that differ between the two.
@@ skipping 28 matching lines @@
    * Get the dependencies at [version] of the package being changed.
    */
   Future<Map<String, PackageRef>> getDependencyRefs(VersionSolver solver,
       Version version) {
     // If there is no version, it means no package, so no dependencies.
     if (version == null) {
       return
           new Future<Map<String, PackageRef>>.immediate(<String, PackageRef>{});
     }
 
-    var id = new PackageId(source, version, description);
+    var id = new PackageId(package, source, version, description);
     return solver._pubspecs.load(id).transform((pubspec) {
       var dependencies = <String, PackageRef>{};
       for (var dependency in pubspec.dependencies) {
         dependencies[dependency.name] = dependency;
       }
       return dependencies;
     });
   }
 }
 
@@ skipping 31 matching lines @@
 
       throw new DisjointConstraintException(name);
     }
 
     // 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 (!newDependency.isDependedOn) {
-      solver.enqueue(new ChangeVersion(source, description, null));
+      solver.enqueue(new ChangeVersion(name, source, description, 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 (name == solver._root.name) {
       solver.enqueue(new ChangeVersion(
-          source, description, solver._root.version));
+          name, source, description, solver._root.version));
       return null;
     }
 
     // If the dependency is on a package in the lockfile, use the lockfile's
     // version for that package if it's valid given the other constraints.
     var lockedPackage = solver.lockFile.packages[name];
     if (lockedPackage != null) {
       var lockedVersion = lockedPackage.version;
       if (newConstraint.allows(lockedVersion)) {
-        solver.enqueue(new ChangeVersion(source, description, lockedVersion));
+        solver.enqueue(
+            new ChangeVersion(name, source, description, lockedVersion));
         return null;
       }
     }
 
     // The constraint has changed, so see what the best version of the package
     // that meets the new constraint is.
     return solver.getBestVersion(newDependency).transform((best) {
       if (best == null) {
         undo(solver);
       } else if (newDependency.version != best) {
-        solver.enqueue(new ChangeVersion(source, description, best));
+        solver.enqueue(new ChangeVersion(name, source, description, best));
       }
     });
   }
 }
 
 /**
  * The constraint given by [ref] is being placed by [depender].
  */
 class AddConstraint extends ChangeConstraint {
   /**
@@ skipping 58 matching lines @@
   /** The package being unlocked. */
   Dependency package;
 
   UnlockPackage(this.package);
 
   Future process(VersionSolver solver) {
     solver.lockFile.packages.remove(package.name);
     return solver.getBestVersion(package).transform((best) {
       if (best == null) return null;
       solver.enqueue(new ChangeVersion(
-          package.source, package.description, best));
+          package.name, package.source, package.description, best));
     });
   }
 }
 
 // TODO(rnystrom): Instead of always pulling from the source (which will mean
 // hitting a server), we should consider caching pubspecs of uninstalled
 // packages in the system cache.
 /**
  * Maintains a cache of previously-loaded pubspecs. Used to avoid requesting
  * the same pubspec from the server repeatedly.
@@ skipping 97 matching lines @@
   Dependency._clone(Dependency other)
       : name = other.name,
         source = other.source,
         description = other.description,
         version = other.version,
         _refs = new Map<String, PackageRef>.from(other._refs);
 
   /** Creates a copy of this dependency. */
   Dependency clone() => new Dependency._clone(this);
 
+  /// Return a list of available versions for this dependency.
+  Future<List<Version>> getVersions() => source.getVersions(name, description);
+
   /**
    * Places [ref] as a constraint from [package] onto this.
    */
   void placeConstraint(String package, PackageRef ref) {
     // If this isn't the first constraint placed on this package, make sure it
     // matches the source and description of past constraints.
     if (_refs.isEmpty()) {
       source = ref.source;
       description = ref.description;
     } else if (source.name != ref.source.name) {
@@ skipping 105 matching lines @@
   final description1;
   final description2;
 
   DescriptionMismatchException(this.package, this.description1,
       this.description2);
 
   // TODO(nweiz): Dump to YAML when that's supported
   String toString() => "Package '$package' has conflicting descriptions "
     "'${JSON.stringify(description1)}' and '${JSON.stringify(description2)}'";
 }