Add "checked" parameter to Isolate.spawnUri.

sdk/lib/isolate/isolate.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.
 
 /**
  * Concurrent programming using _isolates_:
  * independent workers that are similar to threads
  * but don't share memory,
  * communicating only via messages.
  */
@@ skipping 154 matching lines @@
    *
    * The target `main` must be a subtype of one of these three signatures:
    *
    * * `main()`
    * * `main(args)`
    * * `main(args, message)`
    *
    * When present, the parameter `args` is set to the provided [args] list.
    * When present, the parameter `message` is set to the initial [message].
    *
+   * If the [paused] parameter is set to `true`,
+   * the isolate will start up in a paused state,
+   * as if by an initial call of `isolate.pause(isolate.pauseCapability)`.
+   * This allows setting up error or exit listeners on the isolate
+   * before it starts running.
+   * To resume the isolate, call `isolate.resume(isolate.pauseCapability)`.
+   *
+   * If the [checked] parameter is set to `true` or `false`,
+   * the new isolate will run code in checked mode,
+   * respectively in production mode, if possible.
+   * If the parameter is omitted, the new isolate will inherit the
+   * value from the current isolate.
+   *
+   * If the isolate code was pre-compiled, it may not be possible to change
+   * the checked mode setting dynamically.
+   *
+   * WARNING: The [checked] parameter is not implemented on all platforms yet.

[kevmoo, 2015/06/02 17:42:55]

We have no plan to implement this in dart2js, right?

We should be explicit about which platform it is implemented on and the behavior
on unimplemented platforms – noop?

[Lasse Reichstein Nielsen, 2015/06/03 06:55:25]

We could implement it by appending "?checked" to the URI when fetching the file.
Then the server could potentially send a different file if it has one (or
compile it while we wait, if not in a rush).
Dart2js can decide what to do, but doing nothing is an option.
I prefer not to mention specific implementations in the system libraries. It
doesn't make sense in the long run where there might be dozens of platforms.
Should we mention Sky? Dartium? 
I'd prefer to leave it as this - a platform implements this if it can, otherwise
it may be ignored. I'll add some more text to elaborate that.

+   *
    * If the [packageRoot] parameter is provided, it is used to find the location
    * of packages imports in the spawned isolate.
    * The `packageRoot` URI must be a "file" or "http"/"https" URI that specifies
    * a directory. If it doesn't end in a slash, one will be added before
    * using the URI, and any query or fragment parts are ignored.
    * Package imports (like "package:foo/bar.dart") in the new isolate are
    * resolved against this location, as by
    * `packageRoot.resolve("foo/bar.dart")`.
    * This includes the main entry [uri] if it happens to be a package-URL.
    * If [packageRoot] is omitted, it defaults to the same URI that
    * the current isolate is using.
    *
    * WARNING: The [packageRoot] parameter is not implemented on all
    * platforms yet.
    *
-   * If the [paused] parameter is set to `true`,
-   * the isolate will start up in a paused state,
-   * as if by an initial call of `isolate.pause(isolate.pauseCapability)`.
-   * This allows setting up error or exit listeners on the isolate
-   * before it starts running.
-   * To resume the isolate, call `isolate.resume(isolate.pauseCapability)`.
-   *
-   * WARNING: The `pause` parameter is not implemented on all platforms yet.
-   *
    * Returns a future that will complete with an [Isolate] instance if the
    * spawning succeeded. It will complete with an error otherwise.
    */
   external static Future<Isolate> spawnUri(
       Uri uri,
       List<String> args,
       var message,
       {bool paused: false,
+       bool checked,
        Uri packageRoot});
 
   /**
    * Requests the isolate to pause.
    *
    * The isolate should stop handling events by pausing its event queue.
    * The request will eventually make the isolate stop doing anything.
    * It will be handled before any other messages that are later sent to the
    * isolate from the current isolate, but no other guarantees are provided.
    *
@@ skipping 363 matching lines @@
  * as the original error, but has no other features of the original error.
  */
 class RemoteError implements Error {
   final String _description;
   final StackTrace stackTrace;
   RemoteError(String description, String stackDescription)
       : _description = description,
         stackTrace = new StackTrace.fromString(stackDescription);
   String toString() => _description;
 }