anchor.diff:      main();
     }
   
  +  /**
  +   * When [Isolate]s are used as entry-points, the [port] field contains a
  +   * [ReceivePort]. The isolate that initiated the spawn holds a corresponding
  +   * [SendPort].
  +   *
  +   * Note that isolates should generally close their [ReceivePort]s when they
  +   * are done, including this port.
  +   */
     ReceivePort get port() {
       return _port;
     }
   
  -  void main() {
  -  }
  +  /**
  +   * 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;
   
  +  /**
  +   * Before callbacks can be registered in the DOM, they need to be bound
  +   * to the current isolate.
  +   *
  +   * This is necessary due to a bug in the Dart-to-JavaScript pipeline and
  +   * should soon be fixed.
  +   */
     // BUG(5151491): Remove this once we automatically bind functions to
     // the isolate they live in.
     static Function bind(Function f) {
  
positive.code: }
  
  
  interface ReceivePort factory ReceivePortFactory {
  
    /* Opens a long-lived port for receiving messages. The returned port
     * must be explicitly closed through [ReceivePort.close].
     */
    ReceivePort();
  
    /* Opens a single-shot reply port. Once a message has been received
     * on this port, it is automatically closed -- obviously without
     * throwing the message away before it can be processed. This
     * constructor is used indirectly through [SendPort.call].
     */
    ReceivePort.singleShot();
  
    /* Sets up a callback function for receiving pending or future
     * messages on this receive port.
     */
    void receive(void callback(var message, SendPort replyTo));
  
    /* Closes this receive port immediately. Pending messages will not
     * be processed and it is impossible to re-open the port. Reply
     * ports possibly created through [SendPort.call] are automatically
     * closed when the reply has been received. Multiple invocations of
  
negative.code: 
  // Dart core library.
  
  /**
   * [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 {
  
    /**
     * Sends an asynchronous [message] to this send port. The message is
     * copied to the receiving isolate. If the message contains any
     * receive ports, they are translated to the corresponding send port
     * before being transmitted. If specified, the [replyTo] port will be
     * provided to the receiver to facilitate exchanging sequences of
     * messages.
     */
    void send(var message, [SendPort replyTo]);
  
    /**
     * Creates a new single-shot receive port, sends a message to this
     * send port with replyTo set to the opened port, and returns the
     * receive port.
     */
    ReceivePort call(var message);
  
    /**
     * Tests whether [other] is a [SendPort] pointing to the same
     * [ReceivePort] as this one.
     */
     bool operator==(var other);
  
    /**
     * Returns an immutable hash code for this send port that is
     * consistent with the == operator.
     */
    int hashCode();
  