Fix checked mode bugs in pub (and try enabling on bots again).

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 66 matching lines @@
 
     future.then((error) {
       // Null means there were no errors.
       if (error != null) Expect.fail(error);
 
       deleteSandboxIfCreated();
     });
 
     future.handleException((error) {
       deleteSandboxIfCreated();
+      return false;
     });
   });
 }
 
 Future<Directory> _setUpSandbox() {
   return createTempDir('pub-test-sandbox-');
 }
 
 Future _setUpCache(Directory sandboxDir, List<Descriptor> cache) {
   // No cache.
@@ skipping 12 matching lines @@
 Future<ProcessResult> _runPub(List<String> pubArgs, String workingDir) {
   // Find a dart executable we can use to run pub. Uses the one that the
   // test infrastructure uses.
   final scriptDir = new File(new Options().script).directorySync().path;
   final platform = Platform.operatingSystem();
   final dartBin = join(scriptDir, '../../../tools/testing/bin/$platform/dart');
 
   // Find the main pub entrypoint.
   final pubPath = fs.joinPaths(scriptDir, '../../pub/pub.dart');
 
-  final args = [pubPath];
+  final args = ['--enable-type-checks', '--enable-asserts', pubPath];
   args.addAll(pubArgs);
 
   return runProcess(dartBin, args, workingDir);
 }
 
 /**
  * Validates the contents of the "packages" directory inside [appDir] against
  * [expectedPackageDir].
  */
 Future<String> _validateExpectedPackages(Directory appDir,
@@ skipping 58 matching lines @@
    * The short name of this file or directory.
    */
   final String name;
 
   Descriptor(this.name);
 
   /**
    * Creates the file or directory within [dir]. Returns a [Future] that is
    * completed after the creation is done.
    */
-  abstract Future create(String dir);
+  abstract Future create(dir);
 
   /**
    * Validates that this descriptor correctly matches the corresponding file
    * system entry within [dir]. Returns a [Future] that completes to `null` if
    * the entry is valid, or a message describing the error if it failed.
    */
   abstract Future<String> validate(String dir);
 }
 
 /**
  * Describes a file. These are used both for setting up an expected directory
  * tree before running a test, and for validating that the file system matches
  * some expectations after running it.
  */
 class FileDescriptor extends Descriptor {
   /**
    * The text contents of the file.
    */
   final String contents;
 
   FileDescriptor(String name, this.contents) : super(name);
 
   /**
    * Creates the file within [dir]. Returns a [Future] that is completed after
    * the creation is done.
    */
-  Future<File> create(String dir) {
+  Future<File> create(dir) {
     return writeTextFile(join(dir, name), contents);
   }
 
   /**
    * Validates that this file correctly matches the actual file at [path].
    */
   Future<String> validate(String path) {
     path = join(path, name);
     return fileExists(path).chain((exists) {
       if (!exists) {
@@ skipping 20 matching lines @@
    * The files and directories contained in this directory.
    */
   final List<Descriptor> contents;
 
   DirectoryDescriptor(String name, this.contents) : super(name);
 
   /**
    * Creates the file within [dir]. Returns a [Future] that is completed after
    * the creation is done.
    */
-  Future<Directory> create(String parentDir) {
+  Future<Directory> create(parentDir) {
     final completer = new Completer<Directory>();
 
     // Create the directory.
     createDir(join(parentDir, name)).then((dir) {
       if (contents == null) {
         completer.complete(dir);
       } else {
         // Recursively create all of its children.
-        final childFutures = contents.map((child) => child.create(dir.path));
+        final childFutures = contents.map((child) => child.create(dir));
         Futures.wait(childFutures).then((_) {
           // Only complete once all of the children have been created too.
           completer.complete(dir);
         });
       }
     });
 
     return completer.future;
   }
 
@@ skipping 12 matching lines @@
     return Futures.wait(entryFutures).transform((entries) {
       for (final entry in entries) {
         if (entry != null) return entry;
       }
 
       // If we got here, all of the sub-entries were valid.
       return null;
     });
   }
 }