Refactor Source and SourceRegistry.

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.
 
 import 'dart:async';
 import "dart:convert";
 
 import 'package:pub_semver/pub_semver.dart';
 import 'package:stack_trace/stack_trace.dart';
 
 import '../exceptions.dart';
 import '../lock_file.dart';
 import '../log.dart' as log;
 import '../package.dart';
 import '../pubspec.dart';
+import '../system_cache.dart';
 import '../source_registry.dart';
 import '../utils.dart';
 import 'backtracking_solver.dart';
 import 'solve_report.dart';
 
 /// 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 and the requirements imposed by
 /// [lockFile].
 ///
 /// If [useLatest] is given, then only the latest versions of the referenced
 /// packages will be used. This is for forcing an upgrade to one or more
 /// packages.
 ///
 /// If [upgradeAll] is true, the contents of [lockFile] are ignored.
-Future<SolveResult> resolveVersions(SolveType type, SourceRegistry sources,
+Future<SolveResult> resolveVersions(SolveType type, SystemCache cache,
     Package root, {LockFile lockFile, List<String> useLatest}) {
-  if (lockFile == null) lockFile = new LockFile.empty(sources);
+  if (lockFile == null) lockFile = new LockFile.empty(cache.sources);
   if (useLatest == null) useLatest = [];
 
   return log.progress('Resolving dependencies', () {
-    return new BacktrackingSolver(type, sources, root, lockFile, useLatest)
+    return new BacktrackingSolver(type, cache, root, lockFile, useLatest)
         .solve();
   });
 }
 
 /// The result of a version resolution.
 class SolveResult {
   /// Whether the solver found a complete solution or failed.
   bool get succeeded => error == null;
 
   /// The list of concrete package versions that were selected for each package
@@ skipping 90 matching lines @@
              '$error';
     }
 
     return 'Took $attemptedSolutions tries to resolve to\n'
            '- ${packages.join("\n- ")}';
   }
 }
 
 /// Maintains a cache of previously-requested version lists.
 class SolverCache {
-  final SourceRegistry _sources;
+  final SystemCache _cache;
 
   /// 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 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;
 
-  SolverCache(this._type, this._sources);
+  SolverCache(this._type, this._cache);
 
   /// 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 10 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 source = _cache.liveSource(package.source);
     var ids;
     try {
       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);
@@ skipping 227 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) => "";
 }