Refactor Future constructors.

utils/pub/entrypoint.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 entrypoint;
 
 import 'dart:async';
 
 import 'package:pathos/path.dart' as path;
 
@@ skipping 53 matching lines @@
   /// This will automatically install the package to the system-wide cache as
   /// well if it requires network access to retrieve (specifically, if
   /// `id.source.shouldCache` is true).
   ///
   /// See also [installDependencies].
   Future<PackageId> install(PackageId id) {
     var pendingOrCompleted = _installs[id];
     if (pendingOrCompleted != null) return pendingOrCompleted;
 
     var packageDir = path.join(packagesDir, id.name);
-    var future = new Future.of(() {
+    var future = new Future.sync(() {
       ensureDir(path.dirname(packageDir));
 
       if (entryExists(packageDir)) {
         // TODO(nweiz): figure out when to actually delete the directory, and
         // when we can just re-use the existing symlink.
         log.fine("Deleting package directory for ${id.name} before install.");
         deleteEntry(packageDir);
       }
 
       if (id.source.shouldCache) {
@@ skipping 10 matching lines @@
 
     _installs[id] = future;
 
     return future;
   }
 
   /// Installs all dependencies of the [root] package to its "packages"
   /// directory, respecting the [LockFile] if present. Returns a [Future] that
   /// completes when all dependencies are installed.
   Future installDependencies() {
-    return new Future.of(() {
+    return new Future.sync(() {
       return resolveVersions(cache.sources, root, loadLockFile());
     }).then(_installDependencies);
   }
 
   /// Installs the latest available versions of all dependencies of the [root]
   /// package to its "package" directory, writing a new [LockFile]. Returns a
   /// [Future] that completes when all dependencies are installed.
   Future updateAllDependencies() {
     return resolveVersions(cache.sources, root, new LockFile.empty())
         .then(_installDependencies);
   }
 
   /// Installs the latest available versions of [dependencies], while leaving
   /// other dependencies as specified by the [LockFile] if possible. Returns a
   /// [Future] that completes when all dependencies are installed.
   Future updateDependencies(List<String> dependencies) {
-    return new Future.of(() {
+    return new Future.sync(() {
       var solver = new VersionSolver(cache.sources, root, loadLockFile());
       for (var dependency in dependencies) {
         solver.useLatestVersion(dependency);
       }
       return solver.solve();
     }).then(_installDependencies);
   }
 
   /// Removes the old packages directory, installs all dependencies listed in
   /// [packageVersions], and writes a [LockFile].
   Future _installDependencies(List<PackageId> packageVersions) {
-    return new Future.of(() {
+    return new Future.sync(() {
       cleanDir(packagesDir);
       return Future.wait(packageVersions.map((id) {
-        if (id.isRoot) return new Future.immediate(id);
+        if (id.isRoot) return new Future.value(id);
         return install(id);
       }).toList());
     }).then((ids) {
       _saveLockFile(ids);
       _installSelfReference();
       _linkSecondaryPackageDirs();
     });
   }
 
   /// Traverses the root's package dependency graph and loads each of the
   /// reached packages. This should only be called after the lockfile has been
   /// successfully generated.
   Future<List<Pubspec>> walkDependencies() {
-    return new Future.of(() {
+    return new Future.sync(() {
       var lockFile = loadLockFile();
       var group = new FutureGroup<Pubspec>();
       var visited = new Set<String>();
 
       // Include the root package in the results.
-      group.add(new Future.immediate(root.pubspec));
+      group.add(new Future.value(root.pubspec));
 
       visitPackage(Pubspec pubspec) {
         for (var ref in pubspec.dependencies) {
           if (visited.contains(ref.name)) continue;
 
           // Look up the concrete version.
           var id = lockFile.packages[ref.name];
 
           visited.add(ref.name);
           var future;
           if (ref.name == root.name) {
-            future = new Future<Pubspec>.immediate(root.pubspec);
+            future = new Future<Pubspec>.value(root.pubspec);
           } else {
             future = cache.describe(id);
           }
           group.add(future.then(visitPackage));
         }
 
         return pubspec;
       }
 
       visited.add(root.name);
@@ skipping 98 matching lines @@
   }
 
   /// Creates a symlink to the `packages` directory in [dir]. Will replace one
   /// if already there.
   void _linkSecondaryPackageDir(String dir) {
     var symlink = path.join(dir, 'packages');
     if (entryExists(symlink)) deleteEntry(symlink);
     createSymlink(packagesDir, symlink, relative: true);
   }
 }