Add Isolate.current getter, returning the current isolate as an Isolate object.

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 102 matching lines @@
    *
    * If all the available capabilities are included,
    * there is no reason to create a new object,
    * since the behavior is defined entirely
    * by the control port and capabilities.
    */
   Isolate(this.controlPort, {this.pauseCapability,
                              this.terminateCapability});
 
   /**
+   * Return the current isolate.
+   *
+   * This isolate can be sent to other isolates created using [Isolate.spawn]

[floitsch, 2014/12/02 12:13:57]

a: we should agree on terminology for these kind of isolates (and the other
ones). "Local", "same-source", ...

b: I don't think we need to mention this restriction. It's implied by the normal
serialization rules.

c: maybe just add examples instead.

[Lasse Reichstein Nielsen, 2014/12/03 15:34:30]

Removed. Can't think of a short example that isn't entirely contrived.

+   * or its control port and capablities can be sent to isolates created
+   * using [Isolate.spawnUri].
+   * It gives access to the capabilities needed to inspect, pause or kill

[floitsch, 2014/12/02 12:13:56]

New line before?

[Lasse Reichstein Nielsen, 2014/12/03 15:34:30]

Removed the previous paragraph.

+   * the isolate, and allows passing these capabilities to others.
+   */
+  external static Isolate get current;
+
+  /**
    * Creates and spawns an isolate that shares the same code as the current
    * isolate.
    *
    * The argument [entryPoint] specifies the entry point of the spawned
    * isolate. It must be a top-level function or a static method that
    * takes one argument - that is, one-parameter functions that can be
    * compile-time constant function values.
    * It is not allowed to pass the value of function expressions or an instance
    * method extracted from an object.
    *
@@ skipping 467 matching lines @@
       : _description = description,
         stackTrace = new _RemoteStackTrace(stackDescription);
   String toString() => _description;
 }
 
 class _RemoteStackTrace implements StackTrace {
   String _trace;
   _RemoteStackTrace(this._trace);
   String toString() => _trace;
 }