Move pubspec caching into each source.

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 115 matching lines @@
     if (!succeeded) {
       return 'Failed to solve after $attemptedSolutions attempts:\n'
              '$error';
     }
 
     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 {
+/// Maintains a cache of previously-requested version lists.
+class SolverCache {
   final SourceRegistry _sources;
 
-  /// The already-requested cached pubspec lists.
+  /// The already-requested cached version lists.
   final _versions = new Map<PackageRef, List<PackageId>>();
 
   /// The errors from failed version list requests.
   final _versionErrors = new Map<PackageRef, Pair<Object, Chain>>();
 
-  /// The already-requested cached pubspecs.
-  final _pubspecs = new Map<PackageId, Pubspec>();
-
-  // TODO(nweiz): Currently, if [getCachedPubspec] returns pubspecs cached via
-  // [getVersions], the "complex backtrack" test case in version_solver_test
-  // fails. Fix that. See also [BacktrackingSolver._getTransitiveDependers].
-  /// The set of package ids for which [getPubspec] has been explicitly called.
-  final _explicitlyCached = new Set<PackageId>();
-
   /// The type of version resolution that was run.
   final SolveType _type;
 
   /// 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;
 
-  /// The number of times a pubspec was requested and it wasn't cached and had
-  /// to be requested from the source.
-  int _pubspecCacheMisses = 0;
-
-  /// The number of times a pubspec was requested and the cached version was
-  /// returned.
-  int _pubspecCacheHits = 0;
-
-  PubspecCache(this._type, this._sources);
-
-  /// Caches [pubspec] as the [Pubspec] for the package identified by [id].
-  void cache(PackageId id, Pubspec pubspec) {
-    _pubspecs[id] = pubspec;
-  }
-
-  /// Loads the pubspec for the package identified by [id].
-  Future<Pubspec> getPubspec(PackageId id) async {
-    _explicitlyCached.add(id);
-
-    // Complete immediately if it's already cached.
-    if (_pubspecs.containsKey(id)) {
-      _pubspecCacheHits++;
-      return _pubspecs[id];
-    }
-
-    _pubspecCacheMisses++;
-
-    var source = _sources[id.source];
-    var pubspec = await source.describe(id);
-    _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) =>
-      _explicitlyCached.contains(id) ? _pubspecs[id] : null;
+  SolverCache(this._type, this._sources);
 
   /// Gets the list of versions for [package].
   ///
   /// 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.");
@@ skipping 11 matching lines @@
     // 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;
+    var ids;
     try {
-      pubspecs = await source.getVersions(package.name, package.description);
+      ids = await source.getVersions(package);
     } catch (error, stackTrace) {
       // If an error occurs, cache that too. We only want to do one request
       // for any given package, successful or not.
       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) {
+    ids.sort((id1, id2) {
+      // Reverse the IDs because we want the newest version at the front of the
+      // list.
       return _type == SolveType.DOWNGRADE
-          ? Version.antiprioritize(pubspec1.version, pubspec2.version)
-          : Version.prioritize(pubspec1.version, pubspec2.version);
+          ? Version.antiprioritize(id2.version, id1.version)
+          : Version.prioritize(id2.version, id1.version);
     });
 
-    var ids = pubspecs.reversed.map((pubspec) {
-      var id = package.atVersion(pubspec.version);
-      // Eagerly cache the pubspec now since we have it.
-      _pubspecs[id] = pubspec;
-      return id;
-    }).toList();
+    ids = ids.toList();
     _versions[package] = ids;
     return ids;
   }
 
   /// Returns the previously cached list of versions for the package identified
   /// by [package] or returns `null` if not in the cache.
   List<PackageId> getCachedVersions(PackageRef package) => _versions[package];
 
   /// Returns a user-friendly output string describing metrics of the solve.
   String describeResults() {
     var results = '''- Requested $_versionCacheMisses version lists
 - Looked up $_versionCacheHits cached version lists
-- Requested $_pubspecCacheMisses pubspecs
-- Looked up $_pubspecCacheHits cached pubspecs
 ''';
 
     // 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.
@@ skipping 192 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) => "";
 }