Support "--checked" in pub run and global run.

lib/src/executable.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.executable;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:barback/barback.dart';
@@ skipping 26 matching lines @@
 
 /// Runs [executable] from [package] reachable from [entrypoint].
 ///
 /// The executable string is a relative Dart file path using native path
 /// separators with or without a trailing ".dart" extension. It is contained
 /// within [package], which should either be the entrypoint package or an
 /// immediate dependency of it.
 ///
 /// Arguments from [args] will be passed to the spawned Dart application.
 ///
-/// If [mode] is passed, it's used as the barback mode; it defaults to
-/// [BarbackMode.RELEASE].
+/// If [checked] is true, the program is run in checked mode. If [mode] is
+/// passed, it's used as the barback mode; it defaults to [BarbackMode.RELEASE].
 ///
 /// Returns the exit code of the spawned app.
 Future<int> runExecutable(Entrypoint entrypoint, String package,
     String executable, Iterable<String> args, {bool isGlobal: false,
-    BarbackMode mode}) async {
+    bool checked: false, BarbackMode mode}) async {
   if (mode == null) mode = BarbackMode.RELEASE;
 
   // Make sure the package is an immediate dependency of the entrypoint or the
   // entrypoint itself.
   if (entrypoint.root.name != package &&
       !entrypoint.root.immediateDependencies
           .any((dep) => dep.name == package)) {
     var graph = await entrypoint.loadPackageGraph();
     if (graph.packages.containsKey(package)) {
       dataError('Package "$package" is not an immediate dependency.\n'
@@ skipping 13 matching lines @@
   // Ensure that there's a trailing extension.
   if (p.extension(executable) != ".dart") executable += ".dart";
 
   var localSnapshotPath = p.join(".pub", "bin", package,
       "$executable.snapshot");
   if (!isGlobal && fileExists(localSnapshotPath) &&
       // Dependencies are only snapshotted in release mode, since that's the
       // default mode for them to run. We can't run them in a different mode
       // using the snapshot.
       mode == BarbackMode.RELEASE) {
-    return _runCachedExecutable(entrypoint, localSnapshotPath, args);
+    return _runCachedExecutable(entrypoint, localSnapshotPath, args,
+        checked: checked);
   }
 
   // If the command has a path separator, then it's a path relative to the
   // root of the package. Otherwise, it's implicitly understood to be in
   // "bin".
   if (p.split(executable).length == 1) executable = p.join("bin", executable);
 
   var vmArgs = [];
 
   // Run in checked mode.
-  // TODO(rnystrom): Make this configurable.
-  vmArgs.add("--checked");
+  if (checked) vmArgs.add("--checked");
 
   var executableUrl = await _executableUrl(
       entrypoint, package, executable, isGlobal: isGlobal, mode: mode);
 
   if (executableUrl == null) {
     var message = "Could not find ${log.bold(executable)}";
     if (package != entrypoint.root.name) {
       message += " in package ${log.bold(package)}";
     }
     log.error("$message.");
@@ skipping 151 matching lines @@
   for (var signal in _catchableSignals) {
     signal.watch().listen((_) {
       log.fine("Forwarding $signal to running process.");
       process.kill(signal);
     });
   }
 }
 
 /// Runs the executable snapshot at [snapshotPath].
 Future<int> _runCachedExecutable(Entrypoint entrypoint, String snapshotPath,
-    List<String> args) {
-  return runSnapshot(snapshotPath, args, checked: true, recompile: () {
+    List<String> args, {bool checked}) {

[nweiz, 2015/08/06 00:08:28]

": false"

[Bob Nystrom, 2015/08/06 16:54:42]

Done.

+  return runSnapshot(snapshotPath, args, checked: checked, recompile: () {
     log.fine("Precompiled executable is out of date.");
     return entrypoint.precompileExecutables();
   });
 }