Get rid of unneeded Future.immediate() calls.

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 'io.dart';
 import 'lock_file.dart';
 import 'log.dart' as log;
@@ skipping 56 matching lines @@
   ///
   /// See also [installDependencies].
   Future<PackageId> install(PackageId id) {
     var pendingOrCompleted = _installs[id];
     if (pendingOrCompleted != null) return pendingOrCompleted;
 
     var packageDir = join(path, id.name);
     var future = ensureDir(dirname(packageDir)).then((_) {
       return exists(packageDir);
     }).then((exists) {
-      if (!exists) return new Future.immediate(null);
+      if (!exists) return;

[Alan Knight, 2013/01/24 00:03:20]

Being fussy, but seeing as this isn't a void function it seems clearer to me to
explicitly say "return null" than just "return".

[Bob Nystrom, 2013/01/24 00:57:42]

The intent here is to exit the function and not exit with a value. You'll note
the following then() just has _ for the parameter, so this callback doesn't
actually return anything. So I figured "return" was closer to the original
intent.

Or, said another way, if this code didn't have to deal with async shenanigans,
this would just be a bare "return" so I figured I'd do that in the async form
too since I can.

       // 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.");
       return deleteDir(packageDir);
     }).then((_) {
       if (id.source.shouldCache) {
         return cache.install(id).then(
             (pkg) => createPackageSymlink(id.name, pkg.dir, packageDir));
       } else {
         return id.source.install(id, packageDir).then((found) {
@@ skipping 54 matching lines @@
 
   /// Loads the list of concrete package versions from the `pubspec.lock`, if it
   /// exists. If it doesn't, this completes to an empty [LockFile].
   Future<LockFile> loadLockFile() {
     var lockFilePath = join(root.dir, 'pubspec.lock');
 
     log.fine("Loading lockfile.");
     return fileExists(lockFilePath).then((exists) {
       if (!exists) {
         log.fine("No lock file at $lockFilePath, creating empty one.");
-        return new Future<LockFile>.immediate(new LockFile.empty());
+        return new LockFile.empty();
       }
 
       return readTextFile(lockFilePath).then((text) =>
           new LockFile.parse(text, cache.sources));
     });
   }
 
   /// Saves a list of concrete package versions to the `pubspec.lock` file.
   Future _saveLockFile(List<PackageId> packageIds) {
     var lockFile = new LockFile.empty();
     for (var id in packageIds) {
       if (id.source is! RootSource) lockFile.packages[id.name] = id;
     }
 
     var lockFilePath = join(root.dir, 'pubspec.lock');
     log.fine("Saving lockfile.");
     return writeTextFile(lockFilePath, lockFile.serialize());
   }
 
   /// Installs a self-referential symlink in the `packages` directory that will
   /// allow a package to import its own files using `package:`.
   Future _installSelfReference(_) {
     var linkPath = join(path, root.name);
     return exists(linkPath).then((exists) {
       // Create the symlink if it doesn't exist.
-      if (exists) return new Future.immediate(null);
+      if (exists) return;
       return ensureDir(path).then(
           (_) => createPackageSymlink(root.name, root.dir, linkPath,
               isSelfLink: true));
     });
   }
 
   /// If `bin/`, `test/`, or `example/` directories exist, symlink `packages/`
   /// into them so that their entrypoints can be run. Do the same for any
   /// subdirectories of `test/` and `example/`.
   Future _linkSecondaryPackageDirs(_) {
     var binDir = join(root.dir, 'bin');
     var exampleDir = join(root.dir, 'example');
     var testDir = join(root.dir, 'test');
     var toolDir = join(root.dir, 'tool');
     var webDir = join(root.dir, 'web');
     return dirExists(binDir).then((exists) {
-      if (!exists) return new Future.immediate(null);
+      if (!exists) return;
       return _linkSecondaryPackageDir(binDir);
     }).then((_) => _linkSecondaryPackageDirsRecursively(exampleDir))
       .then((_) => _linkSecondaryPackageDirsRecursively(testDir))
       .then((_) => _linkSecondaryPackageDirsRecursively(toolDir))
       .then((_) => _linkSecondaryPackageDirsRecursively(webDir));
   }
 
   /// Creates a symlink to the `packages` directory in [dir] and all its
   /// subdirectories.
   Future _linkSecondaryPackageDirsRecursively(String dir) {
     return dirExists(dir).then((exists) {
-      if (!exists) return new Future.immediate(null);
+      if (!exists) return;
       return _linkSecondaryPackageDir(dir)
         .then((_) => _listDirWithoutPackages(dir))
         .then((files) {
         return Future.wait(files.mappedBy((file) {
           return dirExists(file).then((isDir) {
-            if (!isDir) return new Future.immediate(null);
+            if (!isDir) return;
             return _linkSecondaryPackageDir(file);
           });
         }));
       });
     });
   }
 
   // TODO(nweiz): roll this into [listDir] in io.dart once issue 4775 is fixed.
   /// Recursively lists the contents of [dir], excluding hidden `.DS_Store`
   /// files and `package` files.
   Future<List<String>> _listDirWithoutPackages(dir) {
     return listDir(dir).then((files) {
       return Future.wait(files.mappedBy((file) {
         if (basename(file) == 'packages') return new Future.immediate([]);
         return dirExists(file).then((isDir) {
-          if (!isDir) return new Future.immediate([]);
+          if (!isDir) return [];
           return _listDirWithoutPackages(file);
         }).then((subfiles) {
           var fileAndSubfiles = [file];
           fileAndSubfiles.addAll(subfiles);
           return fileAndSubfiles;
         });
       }));
     }).then(flatten);
   }
 
   /// Creates a symlink to the `packages` directory in [dir] if none exists.
   Future _linkSecondaryPackageDir(String dir) {
     var to = join(dir, 'packages');
     return exists(to).then((exists) {
-      if (exists) return new Future.immediate(null);
+      if (exists) return;
       return createSymlink(path, to);
     });
   }
 }