Refactor Source and SourceRegistry.

lib/src/package_graph.dart

 // Copyright (c) 2013, 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 'barback/transformer_cache.dart';
 import 'entrypoint.dart';
 import 'lock_file.dart';
 import 'package.dart';
 import 'solver/version_solver.dart';
 import 'source/cached.dart';
@@ skipping 30 matching lines @@
   /// This is generally faster than loading a package graph from scratch, since
   /// the packages' pubspecs are already fully-parsed.
   factory PackageGraph.fromSolveResult(Entrypoint entrypoint,
       SolveResult result) {
     var packages = new Map.fromIterable(result.packages,
         key: (id) => id.name,
         value: (id) {
       if (id.name == entrypoint.root.name) return entrypoint.root;
 
       return new Package(result.pubspecs[id.name],
-          entrypoint.cache.sources[id.source].getDirectory(id));
+          entrypoint.cache.source(id.source).getDirectory(id));
     });
 
     return new PackageGraph(entrypoint, result.lockFile, packages);
   }
 
   /// Loads the transformer cache for this graph.
   ///
   /// This may only be called if [entrypoint] represents a physical package.
   /// This may modify the cache.
   TransformerCache loadTransformerCache() {
@@ skipping 56 matching lines @@
   /// Returns whether [package] is mutable.
   ///
   /// A package is considered to be mutable if it or any of its dependencies
   /// don't come from a cached source, since the user can change its contents
   /// without modifying the pub cache. Information generated from mutable
   /// packages is generally not safe to cache, since it may change frequently.
   bool isPackageMutable(String package) {
     var id = lockFile.packages[package];
     if (id == null) return true;
 
-    var source = entrypoint.cache.sources[id.source];
-    if (source is! CachedSource) return true;
+    if (entrypoint.cache.source(id.source) is! CachedSource) return true;
 
     return transitiveDependencies(package).any((dep) {
       var depId = lockFile.packages[dep.name];
 
       // The entrypoint package doesn't have a lockfile entry. It's always
       // mutable.
       if (depId == null) return true;
 
-      return entrypoint.cache.sources[depId.source] is! CachedSource;
+      return entrypoint.cache.source(depId.source) is! CachedSource;
     });
   }
 
   /// Returns whether [package] is static.
   ///
   /// A package is considered to be static if it's not transformed and it came
   /// from a cached source. Static packages don't need to be fully processed by
   /// barback.
   ///
   /// Note that a static package isn't the same as an immutable package (see
   /// [isPackageMutable]).
   bool isPackageStatic(String package) {
     var id = lockFile.packages[package];
     if (id == null) return false;
-
-    var source = entrypoint.cache.sources[id.source];
-    if (source is! CachedSource) return false;
-
+    if (entrypoint.cache.source(id.source) is! CachedSource) return false;
     return packages[package].pubspec.transformers.isEmpty;
   }
 }