Make LockFile immutable.

lib/src/global_packages.dart

 // Copyright (c) 2014, 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.global_packages;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:path/path.dart' as p;
@@ skipping 122 matching lines @@
     // Call this just to log what the current active package is, if any.
     _describeActive(name);
 
     // Write a lockfile that points to the local package.
     var fullPath = canonicalize(entrypoint.root.dir);
     var id = new PackageId(name, "path", entrypoint.root.version,
         PathSource.describePath(fullPath));
 
     // TODO(rnystrom): Look in "bin" and display list of binaries that
     // user can run.
-    _writeLockFile(name, new LockFile([id]));
+    _writeLockFile(name, new LockFile([id], cache.sources));
 
     var binDir = p.join(_directory, name, 'bin');
     if (dirExists(binDir)) deleteEntry(binDir);
 
     _updateBinStubs(entrypoint.root, executables,
         overwriteBinStubs: overwriteBinStubs);
   }
 
   /// Installs the package [dep] and its dependencies into the system cache.
   Future _installInCache(PackageDep dep, List<String> executables,
       {bool overwriteBinStubs}) async {
     // Create a dummy package with just [dep] so we can do resolution on it.
     var root = new Package.inMemory(new Pubspec("pub global activate",
         dependencies: [dep], sources: cache.sources));
 
     // Resolve it and download its dependencies.
     var result = await resolveVersions(SolveType.GET, cache.sources, root);
     if (!result.succeeded) {
       // If the package specified by the user doesn't exist, we want to
       // surface that as a [DataError] with the associated exit code.
       if (result.error.package != dep.name) throw result.error;
       if (result.error is NoVersionException) dataError(result.error.message);
       throw result.error;
     }
     result.showReport(SolveType.GET);
 
     // Make sure all of the dependencies are locally installed.
     var ids = await Future.wait(result.packages.map(_cacheDependency));
-    var lockFile = new LockFile(ids);
+    var lockFile = new LockFile(ids, cache.sources);
 
     // Load the package graph from [result] so we don't need to re-parse all
     // the pubspecs.
     var graph = await new Entrypoint.inMemory(root, lockFile, cache)
         .loadPackageGraph(result);
     var snapshots = await _precompileExecutables(graph.entrypoint, dep.name);
     _writeLockFile(dep.name, lockFile);
     writePackagesMap(graph, _getPackagesFilePath(dep.name));
 
     _updateBinStubs(graph.packages[dep.name], executables,
@@ skipping 40 matching lines @@
   /// Finishes activating package [package] by saving [lockFile] in the cache.
   void _writeLockFile(String package, LockFile lockFile) {
     ensureDir(p.join(_directory, package));
 
     // TODO(nweiz): This cleans up Dart 1.6's old lockfile location. Remove it
     // when Dart 1.6 is old enough that we don't think anyone will have these
     // lockfiles anymore (issue 20703).
     var oldPath = p.join(_directory, "$package.lock");
     if (fileExists(oldPath)) deleteEntry(oldPath);
 
-    writeTextFile(_getLockFilePath(package),
-        lockFile.serialize(cache.rootDir, cache.sources));
+    writeTextFile(_getLockFilePath(package), lockFile.serialize(cache.rootDir));
 
     var id = lockFile.packages[package];
     log.message('Activated ${_formatPackage(id)}.');
   }
 
   /// Shows the user the currently active package with [name], if any.
   void _describeActive(String name) {
     try {
       var lockFile = new LockFile.load(_getLockFilePath(name), cache.sources);
       var id = lockFile.packages[name];
@@ skipping 52 matching lines @@
       } on IOException {
         // If we couldn't read the lock file, it's not activated.
         dataError("No active package ${log.bold(name)}.");
       }
 
       // Move the old lockfile to its new location.
       ensureDir(p.dirname(lockFilePath));
       new File(oldLockFilePath).renameSync(lockFilePath);
     }
 
-    // Load the package from the cache.
+    // Remove the package itself from the lockfile. We put it in there so we
+    // could find and load the [Package] object, but normally an entrypoint
+    // doesn't expect to be in its own lockfile.
     var id = lockFile.packages[name];
-    lockFile.packages.remove(name);
+    lockFile = lockFile.removePackage(name);
 
     var source = cache.sources[id.source];
     if (source is CachedSource) {
       // For cached sources, the package itself is in the cache and the
       // lockfile is the one we just loaded.
       var dir = cache.sources[id.source].getDirectory(id);
       var package = new Package.load(name, dir, cache.sources);
       return new Entrypoint.inMemory(package, lockFile, cache);
     }
 
@@ skipping 464 matching lines @@
   }
 
   /// Returns the value of the property named [name] in the bin stub script
   /// [source].
   String _binStubProperty(String source, String name) {
     var pattern = new RegExp(quoteRegExp(name) + r": ([a-zA-Z0-9_-]+)");
     var match = pattern.firstMatch(source);
     return match == null ? null : match[1];
   }
 }