Create a "PackageRef" class that defines a versionless package reference.

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 version_solver;
 
 import 'dart:async';
 import 'dart:json' as json;
 
 import '../lock_file.dart';
@@ skipping 52 matching lines @@
 
     return 'Took $attemptedSolutions tries to resolve to\n'
            '- ${packages.join("\n- ")}';
   }
 }
 
 /// Maintains a cache of previously-requested data: pubspecs and version lists.
 /// Used to avoid requesting the same pubspec from the server repeatedly.
 class PubspecCache {
   final SourceRegistry _sources;
-  final _versions = new Map<PackageId, List<PackageId>>();
+  final _versions = new Map<PackageRef, List<PackageId>>();
   final _pubspecs = new Map<PackageId, Pubspec>();
 
   /// The number of times a version list was requested and it wasn't cached and
   /// had to be requested from the source.
   int versionCacheMisses = 0;
 
   /// The number of times a version list was requested and the cached version
   /// was returned.
   int versionCacheHits = 0;
 
@@ skipping 28 matching lines @@
       _pubspecs[id] = pubspec;
       return pubspec;
     });
   }
 
   /// Returns the previously cached pubspec for the package identified by [id]
   /// or returns `null` if not in the cache.
   Pubspec getCachedPubspec(PackageId id) => _pubspecs[id];
 
   /// Gets the list of versions for [package] in descending order.
-  Future<List<PackageId>> getVersions(String package, Source source,
-      description) {
-    // Create a fake ID to use as a key.
-    // TODO(rnystrom): Create a separate type for (name, source, description)
-    // without a version.
-    var id = new PackageId(package, source, Version.none, description);
-
+  Future<List<PackageId>> getVersions(PackageRef package) {
     // See if we have it cached.
-    var versions = _versions[id];
+    var versions = _versions[package];
     if (versions != null) {
       versionCacheHits++;
       return new Future.value(versions);
     }
 
     versionCacheMisses++;
-    return source.getVersions(package, description).then((versions) {
-      var ids = versions
-          .map((version) => new PackageId(package, source, version,
-              description))
-          .toList();
-
+    return package.getVersions().then((ids) {
       // Sort by descending version so we try newer versions first.
       ids.sort((a, b) => b.version.compareTo(a.version));
 
       log.solver('requested $package version list');
-      _versions[id] = ids;
+      _versions[package] = ids;
       return ids;
     });
   }
 }
 
 /// 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 referenced dependent package.
-  final PackageRef ref;
+  /// The package being depended on.
+  final PackageDep dep;
 
-  Dependency(this.depender, this.ref);
+  Dependency(this.depender, this.dep);
 
-  String toString() => '$depender -> $ref';
+  String toString() => '$depender -> $dep';
 }
 
 /// Base class for all failures that can occur while trying to resolve versions.
 class SolveFailure implements Exception {
   /// The name of the package whose version could not be solved. Will be `null`
   /// if the failure is not specific to one package.
   final String package;
 
   /// The known dependencies on [package] at the time of the failure. Will be
   /// an empty collection if the failure is not specific to one package.
   final Iterable<Dependency> dependencies;
 
   SolveFailure(this.package, Iterable<Dependency> dependencies)
       : dependencies = dependencies != null ? dependencies : <Dependency>[];
 
   /// Writes [dependencies] to [buffer] as a bullet list. If [describe] is
   /// passed, it will be called for each dependency and the result will be
   /// written next to the dependency.
   void writeDependencies(StringBuffer buffer,
-      [String describe(PackageRef ref)]) {
+      [String describe(PackageDep dep)]) {
     var map = {};
     for (var dep in dependencies) {
-      map[dep.depender] = dep.ref;
+      map[dep.depender] = dep.dep;
     }
 
     var names = map.keys.toList();
     names.sort();
 
     for (var name in names) {
       buffer.writeln("- '$name' ");
       if (describe != null) {
         buffer.writeln(describe(map[name]));
       } else {
         buffer.writeln("depends on version ${map[name].constraint}");
       }
     }
   }
 
   String toString() {
     if (dependencies.isEmpty) return _message;
 
     var buffer = new StringBuffer();
     buffer.writeln("$_message:");
 
     var map = {};
     for (var dep in dependencies) {
-      map[dep.depender] = dep.ref;
+      map[dep.depender] = dep.dep;
     }
 
     var names = map.keys.toList();
     names.sort();
 
     for (var name in names) {
       buffer.writeln("- '$name' ${_describeDependency(map[name])}");
     }
 
     return buffer.toString();
   }
 
   /// A message describing the specific kind of solve failure.
   String get _message;
 
   /// Describes a dependencie's reference in the output message. Override this
-  /// to highlight which aspect of [ref] led to the failure.
-  String _describeDependency(PackageRef ref) =>
-      "depends on version ${ref.constraint}";
+  /// to highlight which aspect of [dep] led to the failure.
+  String _describeDependency(PackageDep dep) =>
+      "depends on version ${dep.constraint}";
 }
 
 /// Exception thrown when the [VersionSolver] fails to find a solution after a
 /// certain number of iterations.
 class CouldNotSolveException extends SolveFailure {
   CouldNotSolveException([String message])
       : super(null, null),
         _message = (message != null) ? message :
             "Could not find a solution that met all constraints.";
 
@@ skipping 41 matching lines @@
 
 /// Exception thrown when two packages with the same name but different sources
 /// are depended upon.
 class SourceMismatchException extends SolveFailure {
 
   SourceMismatchException(String package, Iterable<Dependency> dependencies)
       : super(package, dependencies);
 
   String get _message => "Incompatible dependencies on '$package'";
 
-  String _describeDependency(PackageRef ref) =>
-      "depends on it from source ${ref.source}";
+  String _describeDependency(PackageDep dep) =>
+      "depends on it from source ${dep.source}";
 }
 
 /// Exception thrown when two packages with the same name and source but
 /// different descriptions are depended upon.
 class DescriptionMismatchException extends SolveFailure {
   DescriptionMismatchException(String package,
       Iterable<Dependency> dependencies)
       : super(package, dependencies);
 
   String get _message => "Incompatible dependencies on '$package'";
 
-  String _describeDependency(PackageRef ref) {
+  String _describeDependency(PackageDep dep) {
     // TODO(nweiz): Dump descriptions to YAML when that's supported.
-    return "depends on it with description ${json.stringify(ref.description)}";
+    return "depends on it with description ${json.stringify(dep.description)}";
   }
 }