Make mappedBy lazy.

utils/tests/pub/test_pub.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.
 
 /**
  * Test infrastructure for testing pub. Unlike typical unit tests, most pub
  * tests are integration tests that stage some stuff on the file system, run
  * pub, and then validate the results. This library provides an API to build
  * tests like that.
  */
@@ skipping 892 matching lines @@
   /**
    * Creates the file within [dir]. Returns a [Future] that is completed after
    * the creation is done.
    */
   Future<Directory> create(parentDir) {
     // Create the directory.
     return ensureDir(join(parentDir, _stringName)).chain((dir) {
       if (contents == null) return new Future<Directory>.immediate(dir);
 
       // Recursively create all of its children.
-      final childFutures = contents.mappedBy((child) => child.create(dir));
+      final childFutures =
+          contents.mappedBy((child) => child.create(dir)).toList();
       // Only complete once all of the children have been created too.
       return Futures.wait(childFutures).transform((_) => dir);
     });
   }
 
   /**
    * Deletes the directory within [dir]. Returns a [Future] that is completed
    * after the deletion is done.
    */
   Future delete(dir) {
     return deleteDir(join(dir, _stringName));
   }
 
   /**
    * Validates that the directory at [path] contains all of the expected
    * contents in this descriptor. Note that this does *not* check that the
    * directory doesn't contain other unexpected stuff, just that it *does*
    * contain the stuff we do expect.
    */
   Future validate(String path) {
     return _validateOneMatch(path, (dir) {
       // Validate each of the items in this directory.
-      final entryFutures = contents.mappedBy((entry) => entry.validate(dir));
+      final entryFutures =
+          contents.mappedBy((entry) => entry.validate(dir)).toList();
 
       // If they are all valid, the directory is valid.
       return Futures.wait(entryFutures).transform((entries) => null);
     });
   }
 
   /**
    * Loads [path] from within this directory.
    */
   InputStream load(List<String> path) {
@@ skipping 244 matching lines @@
 }
 
 /**
  * Takes a simple data structure (composed of [Map]s, [List]s, scalar objects,
  * and [Future]s) and recursively resolves all the [Future]s contained within.
  * Completes with the fully resolved structure.
  */
 Future _awaitObject(object) {
   // Unroll nested futures.
   if (object is Future) return object.chain(_awaitObject);
-  if (object is Collection) return Futures.wait(object.mappedBy(_awaitObject));
+  if (object is Collection) {
+    return Futures.wait(object.mappedBy(_awaitObject).toList());
+  }
   if (object is! Map) return new Future.immediate(object);
 
   var pairs = <Future<Pair>>[];
   object.forEach((key, value) {
     pairs.add(_awaitObject(value)
         .transform((resolved) => new Pair(key, resolved)));
   });
   return Futures.wait(pairs).transform((resolvedPairs) {
     var map = {};
     for (var pair in resolvedPairs) {
@@ skipping 12 matching lines @@
 }
 
 /**
  * Schedules a callback to be called after Pub is run with [runPub], even if it
  * fails.
  */
 void _scheduleCleanup(_ScheduledEvent event) {
   if (_scheduledCleanup == null) _scheduledCleanup = [];
   _scheduledCleanup.add(event);
 }