isolates refactor: this change introduces 'dart:isolate' as a library. This is a

lib/isolate/isolate_api.dart

 // Copyright (c) 2011, 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.
 
-// Dart core library.
-// TODO(sigmund): move to dart:isolate
-
 /**
  * [SendPort]s are created from [ReceivePort]s. Any message sent through
  * a [SendPort] is delivered to its respective [ReceivePort]. There might be
  * many [SendPort]s for the same [ReceivePort].
  *
  * [SendPort]s can be transmitted to other isolates.
  */
 interface SendPort extends Hashable {
 
   /**
@@ skipping 122 matching lines @@
    * inside the new isolate and stored in the read-only field [port].
    *  A corresponding [SendPort] is sent to the isolate that invoked [spawn].
    * Since spawning an isolate is an asynchronous operation this method returns
    * a [Future] of this [SendPort].
    *
    * A common pattern to instantiate new isolates is to enqueue the instructions
    * using [Future.then].
    * [:myIsolate.spawn().then((SendPort port) { port.send('hi there'); });:]
    */
   Future<SendPort> spawn() {
-    return IsolateNatives.spawn(this, _isLight);
+    return _IsolateNatives.spawn(this, _isLight);
   }
 
   // The private run method is invoked with the receive port. Before
   // main is invoked we store the port in a field so it can be
   // accessed from subclasses of Isolate.
   void _run(ReceivePort port) {
     _port = port;
     main();
   }
 
@@ skipping 12 matching lines @@
   /**
    * When isolates are created, an instance of the template's class is
    * instantiated in the new isolate. After the [port] has been set up, this
    * [main] method is invoked on the instance.
    */
   abstract void main();
 
   final bool _isLight;
   ReceivePort _port;
 }
+
+/**
+ * [Isolate2] provides APIs to spawn, communicate, and stop an isolate. An
+ * isolate can be spawned by simply creating a new instance of [Isolate2]. The
+ * [Isolate2] instance exposes a port to communicate with the isolate and
+ * methods to control its behavior remotely.
+ */
+ // TODO(sigmund): rename to Isolate once we delete the old implementation
+interface Isolate2 default _IsolateFactory {
+
+  /**
+   * Create and spawn an isolate that shares the same code as the current
+   * isolate, but that starts from [topLevelFunction]. The [topLevelFunction]
+   * argument must be a static method closure that takes exactly one
+   * argument of type [ReceivePort]. It is illegal to pass a function closure
+   * that captures values in scope.
+   *
+   * When an child isolate is spawned, a new [ReceivePort] is created for it.
+   * This port is passed to [topLevelFunction]. A [SendPort] derived from
+   * such port is sent to the spawner isolate, which is accessible in
+   * [Isolate2.sendPort] field of this instance.
+   */
+  Isolate2.fromCode(Function topLevelFunction);
+
+  /**
+   * Create and spawn an isolate whose code is available at [uri].
+   * The code in [uri] must have an method called [: isolateMain :], which takes
+   * exactly one argument of type [ReceivePort].
+   * Like with [Isolate2.fromCode], a [ReceivePort] is created in the child
+   * isolate, and a [SendPort] to it is stored in [Isolate2.sendPort].
+   */
+  Isolate2.fromUri(String uri);
+
+  /** Port used to communicate with this isolate. */
+  SendPort sendPort;
+
+  /** Stop this isolate. */
+  void stop();

[siva, 2012/02/22 00:58:20]

What is the semantics of this stop? Could you document it more. Is the caller
guaranteed that the isolate has been stopped when this returns or are in just
requesting the other isolate to stop? If it is the later than please rename  the
method.

It is generally a bad idea to allow an isolated to be 'stopped' from another
isolate (case in point - the method Thread.stop from another language was
deprecated quickly once people realized all the problems associated with it).

[Siggi Cherem (dart-lang), 2012/02/22 19:18:50]

This is something that we were planning to remove, so I just went ahead and
delete it. The code was here because I was only doing refactoring (this code
came from another location)

+}